using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using MenuLib;
using MenuLib.MonoBehaviors;
using MenuLib.Structs;
using Microsoft.CodeAnalysis;
using POpusCodec.Enums;
using Photon.Pun;
using Photon.Realtime;
using Photon.Voice;
using Photon.Voice.Unity;
using SharePermissions.Core;
using SharePermissions.Net;
using SharePermissions.Net.Commands;
using SharePermissions.Patches;
using SharePermissions.Players;
using SharePermissions.UI;
using SharePermissions.Voice;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.TextCore;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("RED")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("2.4.2.0")]
[assembly: AssemblyInformationalVersion("2.4.2+7581cc1fa5ca36b471ae197025cadb2d1e834ffe")]
[assembly: AssemblyProduct("SharePermissions")]
[assembly: AssemblyTitle("SharePermissions")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.4.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace SharePermissions.Voice
{
	internal sealed class MicRing
	{
		private readonly float[] buffer;

		private volatile int writeIndex;

		private volatile int readIndex;

		private volatile float level;

		internal float Level => level;

		internal int Available
		{
			get
			{
				int num = writeIndex;
				int num2 = readIndex;
				if (num < num2)
				{
					return buffer.Length - num2 + num;
				}
				return num - num2;
			}
		}

		internal MicRing(int capacity)
		{
			if (capacity < 2)
			{
				capacity = 2;
			}
			buffer = new float[capacity];
		}

		internal void Write(float[] data, int count)
		{
			if (data != null && count > 0)
			{
				if (count > data.Length)
				{
					count = data.Length;
				}
				float num = 0f;
				for (int i = 0; i < count; i++)
				{
					num += Math.Abs(data[i]);
				}
				level = num / (float)count;
				int num2 = writeIndex;
				int num3 = buffer.Length - 1 - Available;
				if (count > num3)
				{
					count = num3;
				}
				for (int j = 0; j < count; j++)
				{
					buffer[num2] = data[j];
					num2 = ((num2 + 1 != buffer.Length) ? (num2 + 1) : 0);
				}
				writeIndex = num2;
			}
		}

		internal bool Read(float[] destination)
		{
			if (destination == null || destination.Length == 0)
			{
				return false;
			}
			if (Available < destination.Length)
			{
				return false;
			}
			int num = readIndex;
			for (int i = 0; i < destination.Length; i++)
			{
				destination[i] = buffer[num];
				num = ((num + 1 != buffer.Length) ? (num + 1) : 0);
			}
			readIndex = num;
			return true;
		}

		internal void Reset()
		{
			readIndex = 0;
			writeIndex = 0;
			level = 0f;
		}
	}
	[HarmonyPatch(typeof(MicWrapper), "Read")]
	internal static class MicTee
	{
		private const int RingCapacity = 48000;

		internal static readonly MicRing Ring = new MicRing(48000);

		private static volatile int samplingRate;

		private static volatile int channels;

		internal static int SamplingRate => samplingRate;

		internal static int Channels => channels;

		internal static bool IsLive
		{
			get
			{
				if (SamplingRate > 0)
				{
					return Channels > 0;
				}
				return false;
			}
		}

		internal static float Level => Ring.Level;

		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Read_Postfix(MicWrapper __instance, float[] buffer, bool __result)
		{
			if (__result && buffer != null && PrivateVoiceGate.WantCapture)
			{
				channels = __instance.Channels;
				samplingRate = __instance.SamplingRate;
				Ring.Write(buffer, buffer.Length);
			}
		}

		internal static void Flush()
		{
			Ring.Reset();
			Plugin.Logger.LogDebug((object)"Private voice: mic tee flushed");
		}
	}
	internal static class PrivateVoiceGate
	{
		internal static volatile bool WantCapture;
	}
	internal static class PrivateSpeakers
	{
		private sealed class Entry
		{
			internal GameObject Go;

			internal Speaker Speaker;

			internal AudioSource Source;

			internal PrivateSpeakerGain Gain;

			internal int Actor;

			internal volatile float Amplitude;
		}

		private static readonly Dictionary<int, Entry> ByPlayerId = new Dictionary<int, Entry>();

		private static readonly HashSet<Speaker> AmplitudeAttached = new HashSet<Speaker>();

		private static float volume = 1f;

		internal static Speaker? Create(int playerId, object userData)
		{
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			if (!(userData is int num) || num <= 0)
			{
				Plugin.Logger.LogWarning((object)$"Private voice: stream {playerId} carried no usable actor claim - refusing");
				return null;
			}
			if (!PrivateVoiceChannel.IsMemberActor(num))
			{
				Plugin.Logger.LogWarning((object)$"Private voice: stream from non-member actor {num} - refusing to play");
				return null;
			}
			foreach (KeyValuePair<int, Entry> item in ByPlayerId)
			{
				if (item.Key != playerId && item.Value.Actor == num)
				{
					Plugin.Logger.LogWarning((object)$"Private voice: actor {num} already claimed by another stream - refusing");
					return null;
				}
			}
			if (ByPlayerId.TryGetValue(playerId, out Entry value))
			{
				return value.Speaker;
			}
			GameObject val = new GameObject($"SP_PrivSpeaker_a{num}");
			Object.DontDestroyOnLoad((Object)(object)val);
			AudioSource val2 = val.AddComponent<AudioSource>();
			val2.spatialBlend = 0f;
			val2.mute = false;
			val2.dopplerLevel = 0f;
			val2.priority = 0;
			val2.outputAudioMixerGroup = null;
			val2.bypassEffects = false;
			val2.bypassListenerEffects = true;
			val2.bypassReverbZones = true;
			PrivateSpeakerGain gain = val.AddComponent<PrivateSpeakerGain>();
			Speaker val3 = val.AddComponent<Speaker>();
			Entry entry = new Entry
			{
				Go = val,
				Speaker = val3,
				Source = val2,
				Gain = gain,
				Actor = num
			};
			ByPlayerId[playerId] = entry;
			Apply(entry, volume);
			val3.OnRemoteVoiceRemoveAction = delegate(Speaker s)
			{
				ByPlayerId.Remove(playerId);
				if ((Object)(object)s != (Object)null && (Object)(object)((Component)s).gameObject != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)s).gameObject);
				}
			};
			Plugin.Logger.LogInfo((object)$"Private voice: speaker for actor {num}");
			return val3;
		}

		internal static void AttachAmplitude(Speaker speaker)
		{
			if ((Object)(object)speaker == (Object)null)
			{
				return;
			}
			RemoteVoiceLink remoteVoice = speaker.RemoteVoice;
			if (remoteVoice == null)
			{
				return;
			}
			Entry entry = null;
			foreach (KeyValuePair<int, Entry> item in ByPlayerId)
			{
				if (item.Value.Speaker == speaker)
				{
					entry = item.Value;
					break;
				}
			}
			if (entry == null || !AmplitudeAttached.Add(speaker))
			{
				return;
			}
			remoteVoice.FloatFrameDecoded += delegate(FrameOut<float> frame)
			{
				float[] buf = frame.Buf;
				if (buf != null && buf.Length != 0)
				{
					float num = 0f;
					for (int i = 0; i < buf.Length; i++)
					{
						num += ((buf[i] < 0f) ? (0f - buf[i]) : buf[i]);
					}
					entry.Amplitude = num / (float)buf.Length;
				}
			};
		}

		internal static void DestroyAll()
		{
			foreach (KeyValuePair<int, Entry> item in ByPlayerId)
			{
				Entry value = item.Value;
				if ((Object)(object)value.Speaker != (Object)null)
				{
					value.Speaker.OnRemoteVoiceRemoveAction = null;
				}
				if ((Object)(object)value.Go != (Object)null)
				{
					Object.Destroy((Object)(object)value.Go);
				}
			}
			ByPlayerId.Clear();
			AmplitudeAttached.Clear();
		}

		internal static float AmplitudeFor(int actorNumber)
		{
			foreach (KeyValuePair<int, Entry> item in ByPlayerId)
			{
				if (item.Value.Actor == actorNumber)
				{
					return item.Value.Amplitude;
				}
			}
			return 0f;
		}

		internal static int[] SpeakingActors()
		{
			List<int> list = new List<int>(ByPlayerId.Count);
			foreach (KeyValuePair<int, Entry> item in ByPlayerId)
			{
				list.Add(item.Value.Actor);
			}
			return list.ToArray();
		}

		internal static void SetVolume(float value)
		{
			if (value < 0f)
			{
				value = 0f;
			}
			float num = 3f;
			if (value > num)
			{
				value = num;
			}
			volume = value;
			foreach (KeyValuePair<int, Entry> item in ByPlayerId)
			{
				Apply(item.Value, value);
			}
		}

		private static void Apply(Entry entry, float value)
		{
			if ((Object)(object)entry.Source != (Object)null)
			{
				entry.Source.volume = ((value > 1f) ? 1f : value);
			}
			if ((Object)(object)entry.Gain != (Object)null)
			{
				entry.Gain.Gain = ((value > 1f) ? value : 1f);
			}
		}
	}
	internal sealed class PrivateSpeakerGain : MonoBehaviour
	{
		private volatile float gain = 1f;

		internal float Gain
		{
			get
			{
				return gain;
			}
			set
			{
				gain = ((value < 1f) ? 1f : value);
			}
		}

		private void OnAudioFilterRead(float[] data, int channels)
		{
			float num = gain;
			if (num != 1f)
			{
				for (int i = 0; i < data.Length; i++)
				{
					data[i] *= num;
				}
			}
		}
	}
	internal sealed class PrivateVoiceClient : VoiceFollowClient
	{
		private const float ConnectWarnCooldownSeconds = 5f;

		private const float ConnectRetryCooldownSeconds = 3f;

		private static bool quitting;

		private string token = string.Empty;

		private Recorder? recorder;

		private int userDataActor;

		private float nextConnectWarnAt;

		private float nextConnectAttemptAt;

		internal static PrivateVoiceClient? Instance { get; private set; }

		internal static bool EverCreated { get; private set; }

		internal Recorder? PrivateRecorder => recorder;

		protected override bool LeaderInRoom
		{
			get
			{
				if (PhotonNetwork.InRoom)
				{
					return PrivateVoiceChannel.IsValidRoomName(token);
				}
				return false;
			}
		}

		protected override bool LeaderOfflineMode => PhotonNetwork.OfflineMode;

		internal static void Init()
		{
			//IL_0013: 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_0021: Expected O, but got Unknown
			if (!((Object)(object)Instance != (Object)null))
			{
				GameObject val = new GameObject("SP_PrivateVoice")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)(object)val);
				Instance = val.AddComponent<PrivateVoiceClient>();
				((VoiceConnection)Instance).SpeakerLinked += PrivateSpeakers.AttachAmplitude;
				EverCreated = true;
				Application.quitting += delegate
				{
					quitting = true;
				};
				Plugin.Logger.LogInfo((object)"Private voice client created");
			}
		}

		internal void Provision(string roomName)
		{
			if (!PrivateVoiceChannel.IsValidRoomName(roomName))
			{
				Plugin.Logger.LogWarning((object)"Private voice: refusing a malformed room name");
				return;
			}
			PrivateVoiceGate.WantCapture = true;
			bool flag = PhotonNetwork.InRoom && PhotonNetwork.LocalPlayer != null && PhotonNetwork.LocalPlayer.ActorNumber > 0;
			if ((Object)(object)recorder == (Object)null)
			{
				if (flag && MicTee.IsLive)
				{
					CreateRecorder();
				}
			}
			else if (flag)
			{
				SyncUserData(recorder);
			}
			bool flag2 = ((VoiceConnection)this).Client != null && ((LoadBalancingClient)((VoiceConnection)this).Client).IsConnected;
			if (roomName == token && flag2)
			{
				return;
			}
			if (token.Length > 0 && roomName != token)
			{
				token = string.Empty;
				SafeDisconnect();
				return;
			}
			if (token.Length == 0)
			{
				if (flag2)
				{
					return;
				}
				token = roomName;
			}
			if (!(((VoiceConnection)this).Client == null || flag2) && PhotonNetwork.InRoom && !(Time.unscaledTime < nextConnectAttemptAt))
			{
				nextConnectAttemptAt = Time.unscaledTime + 3f;
				if (!((VoiceFollowClient)this).ConnectAndJoinRoom() && Time.unscaledTime >= nextConnectWarnAt)
				{
					nextConnectWarnAt = Time.unscaledTime + 5f;
					Plugin.Logger.LogWarning((object)("Private voice: connect/join refused for room " + PrivateVoiceChannel.Fingerprint(roomName)));
				}
			}
		}

		protected override void Start()
		{
			((VoiceFollowClient)this).Start();
			if (PhotonNetwork.NetworkingClient != null)
			{
				PhotonNetwork.NetworkingClient.StateChanged += OnLeaderStateChanged;
			}
		}

		private void OnLeaderStateChanged(ClientState fromState, ClientState toState)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			((VoiceFollowClient)this).LeaderStateChanged(toState);
		}

		protected override void OnDestroy()
		{
			if (Instance == this && !quitting)
			{
				Plugin.Logger.LogWarning((object)"Private voice: SP_PrivateVoice is being destroyed - the private channel cannot run again this session");
			}
			if (PhotonNetwork.NetworkingClient != null)
			{
				PhotonNetwork.NetworkingClient.StateChanged -= OnLeaderStateChanged;
			}
			((VoiceFollowClient)this).OnDestroy();
		}

		private void CreateRecorder()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SP_PrivateRecorder");
			val.transform.SetParent(((Component)this).transform, false);
			Recorder val2 = val.AddComponent<Recorder>();
			PrivateVoiceDsp.Mirror(val);
			val2.SourceType = (InputSourceType)2;
			val2.MicrophoneType = (MicType)1;
			val2.InputFactory = () => (IAudioDesc)(object)new TeeAudioReader();
			userDataActor = PhotonNetwork.LocalPlayer.ActorNumber;
			val2.UserData = userDataActor;
			val2.TransmitEnabled = false;
			val2.VoiceDetection = false;
			val2.Encrypt = true;
			val2.DebugEchoMode = false;
			val2.InterestGroup = 0;
			val2.TargetPlayers = null;
			val2.SamplingRate = NearestSupportedRate(MicTee.SamplingRate);
			((VoiceConnection)this).PrimaryRecorder = val2;
			if (!((VoiceConnection)this).AddRecorder(val2))
			{
				Plugin.Logger.LogWarning((object)"Private voice: AddRecorder refused - the recorder will never transmit");
				Object.Destroy((Object)(object)val);
			}
			else
			{
				recorder = val2;
				Plugin.Logger.LogInfo((object)$"Private voice recorder ready ({MicTee.SamplingRate} Hz, {MicTee.Channels} ch)");
			}
		}

		private void SyncUserData(Recorder rec)
		{
			int actorNumber = PhotonNetwork.LocalPlayer.ActorNumber;
			if (actorNumber != userDataActor)
			{
				userDataActor = actorNumber;
				rec.UserData = actorNumber;
				Plugin.Logger.LogInfo((object)"Private voice: local actor number changed, rebinding recorder identity");
			}
		}

		private static SamplingRate NearestSupportedRate(int hz)
		{
			//IL_0041: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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)
			if (hz <= 20000)
			{
				if (hz > 10000)
				{
					if (hz <= 14000)
					{
						return (SamplingRate)12000;
					}
					return (SamplingRate)16000;
				}
				return (SamplingRate)8000;
			}
			if (hz <= 36000)
			{
				return (SamplingRate)24000;
			}
			return (SamplingRate)48000;
		}

		internal bool ChannelLive(string expectedRoom)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			if (((VoiceConnection)this).Client == null || (int)((LoadBalancingClient)((VoiceConnection)this).Client).State != 9)
			{
				return false;
			}
			Room currentRoom = ((LoadBalancingClient)((VoiceConnection)this).Client).CurrentRoom;
			if (currentRoom != null && currentRoom.Name == expectedRoom)
			{
				return PrivateVoiceChannel.IsValidRoomName(currentRoom.Name);
			}
			return false;
		}

		private void SafeDisconnect()
		{
			if (((VoiceConnection)this).Client != null && ((LoadBalancingClient)((VoiceConnection)this).Client).IsConnected)
			{
				((VoiceFollowClient)this).Disconnect();
			}
		}

		internal void TearDown()
		{
			if ((Object)(object)recorder != (Object)null)
			{
				recorder.TransmitEnabled = false;
			}
			PrivateSpeakers.DestroyAll();
			SafeDisconnect();
			PrivateVoiceGate.WantCapture = false;
			MicTee.Flush();
			token = string.Empty;
			nextConnectWarnAt = 0f;
			nextConnectAttemptAt = 0f;
		}

		protected override string GetVoiceRoomName()
		{
			return token;
		}

		protected override bool ConnectVoice()
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0076: Expected O, but got Unknown
			AppSettings val = null;
			((LoadBalancingClient)((VoiceConnection)this).Client).ServerPortOverrides = PhotonNetwork.ServerPortOverrides;
			val = PhotonNetwork.PhotonServerSettings.AppSettings.CopyTo(new AppSettings());
			if (!string.IsNullOrEmpty(PhotonNetwork.CloudRegion))
			{
				val.FixedRegion = PhotonNetwork.CloudRegion;
			}
			((LoadBalancingClient)((VoiceConnection)this).Client).SerializationProtocol = PhotonNetwork.NetworkingClient.SerializationProtocol;
			if (PhotonNetwork.AuthValues != null)
			{
				LoadBalancingTransport client = ((VoiceConnection)this).Client;
				if (((LoadBalancingClient)client).AuthValues == null)
				{
					AuthenticationValues val2 = new AuthenticationValues();
					AuthenticationValues val3 = val2;
					((LoadBalancingClient)client).AuthValues = val2;
				}
				((LoadBalancingClient)((VoiceConnection)this).Client).AuthValues = PhotonNetwork.AuthValues.CopyTo(((LoadBalancingClient)((VoiceConnection)this).Client).AuthValues);
			}
			((LoadBalancingClient)((VoiceConnection)this).Client).AuthMode = PhotonNetwork.NetworkingClient.AuthMode;
			((LoadBalancingClient)((VoiceConnection)this).Client).EncryptionMode = PhotonNetwork.NetworkingClient.EncryptionMode;
			return ((VoiceConnection)this).ConnectUsingSettings(val);
		}

		protected override bool JoinVoiceRoom(string voiceRoomName)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_0033: 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_0046: Expected O, but got Unknown
			//IL_0046: 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_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_006b: Expected O, but got Unknown
			if (!PrivateVoiceChannel.IsValidRoomName(voiceRoomName))
			{
				Plugin.Logger.LogWarning((object)"Private voice: join refused, malformed room name");
				return false;
			}
			RoomOptions roomOptions = new RoomOptions
			{
				IsVisible = false,
				IsOpen = true,
				MaxPlayers = 0,
				PlayerTtl = 2000,
				PublishUserId = true
			};
			EnterRoomParams val = new EnterRoomParams
			{
				RoomName = voiceRoomName,
				RoomOptions = roomOptions,
				Lobby = new TypedLobby("spv", (LobbyType)0)
			};
			Plugin.Logger.LogInfo((object)("Private voice: joining room " + PrivateVoiceChannel.Fingerprint(voiceRoomName)));
			return ((LoadBalancingClient)((VoiceConnection)this).Client).OpJoinOrCreateRoom(val);
		}

		protected override void OnOperationResponseReceived(OperationResponse operationResponse)
		{
			if (operationResponse.ReturnCode == 0)
			{
				((VoiceFollowClient)this).OnOperationResponseReceived(operationResponse);
				return;
			}
			Plugin.Logger.LogWarning((object)$"Private voice: op {operationResponse.OperationCode} failed ({operationResponse.ReturnCode})");
			if (operationResponse.OperationCode != 226)
			{
				((VoiceFollowClient)this).OnOperationResponseReceived(operationResponse);
				return;
			}
			string roomName = token;
			try
			{
				token = PrivateVoiceChannel.Fingerprint(roomName);
				((VoiceFollowClient)this).OnOperationResponseReceived(operationResponse);
			}
			finally
			{
				token = roomName;
			}
		}

		protected override Speaker? InstantiateSpeakerForRemoteVoice(int playerId, byte voiceId, object userData)
		{
			try
			{
				return PrivateSpeakers.Create(playerId, userData);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Private voice: speaker construction failed: {arg}");
				return null;
			}
		}
	}
	internal static class PrivateVoiceDriver
	{
		internal enum Health
		{
			Off,
			Provisioning,
			Live,
			Listening,
			Failed
		}

		private const float ReleaseGraceSeconds = 0.3f;

		private const float IntrusionConfirmSeconds = 2f;

		private const float MissingClientWarnCooldownSeconds = 5f;

		private static bool lastVoiceJoined;

		private static float releaseAt;

		private static float nextMissingClientWarnAt;

		private static string provisionedRoom = string.Empty;

		private static float unexpectedOccupantFirstSeenAt = -1f;

		internal static Health State { get; private set; } = Health.Off;

		internal static void Tick()
		{
			int num = ((PhotonNetwork.InRoom && PhotonNetwork.LocalPlayer != null) ? PhotonNetwork.LocalPlayer.ActorNumber : 0);
			PrivateVoiceChannel.SetLocalMembership(num > 0 && PrivateVoiceChannel.IsMemberActor(num));
			bool localActive = PrivateVoiceChannel.LocalActive;
			if (!localActive && provisionedRoom.Length > 0)
			{
				TearDown("mode off");
			}
			RecorderTransmitPatch.Suppress = localActive || Time.realtimeSinceStartup < releaseAt;
			if (!localActive)
			{
				if (Time.realtimeSinceStartup < releaseAt)
				{
					ForceGameRecorderOff();
				}
				State = Health.Off;
				return;
			}
			ForceGameRecorderOff();
			PrivateSpeakers.SetVolume(GameVolume() * PrivateVoiceLocalPrefs.Factor);
			PrivateVoiceClient instance = PrivateVoiceClient.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				if (Time.realtimeSinceStartup >= nextMissingClientWarnAt)
				{
					nextMissingClientWarnAt = Time.realtimeSinceStartup + 5f;
					Plugin.Logger.LogWarning((object)(PrivateVoiceClient.EverCreated ? "Private voice: the voice client was created at startup but no longer exists - something destroyed the SP_PrivateVoice object, so the channel cannot run" : "Private voice: the voice client was never created - PrivateVoiceClient.Init did not run or threw"));
				}
				State = Health.Failed;
				return;
			}
			string roomName = PrivateVoiceChannel.RoomName;
			if (provisionedRoom != roomName)
			{
				if (provisionedRoom.Length > 0)
				{
					TearDown("room rotated");
				}
				else
				{
					MicTee.Flush();
				}
				instance.Provision(roomName);
				provisionedRoom = roomName;
				State = Health.Provisioning;
				return;
			}
			if ((Object)(object)instance.PrivateRecorder == (Object)null)
			{
				instance.Provision(roomName);
				bool flag = instance.ChannelLive(roomName);
				if (!lastVoiceJoined && flag)
				{
					MicTee.Flush();
				}
				lastVoiceJoined = flag;
				State = ((!flag) ? Health.Provisioning : Health.Listening);
				return;
			}
			bool flag2 = instance.ChannelLive(roomName);
			if (!lastVoiceJoined && flag2)
			{
				MicTee.Flush();
			}
			if (lastVoiceJoined && !flag2)
			{
				Plugin.Logger.LogInfo((object)"Private voice: channel dropped, re-provisioning");
			}
			lastVoiceJoined = flag2;
			if (!flag2)
			{
				instance.Provision(roomName);
				SetPrivateTransmit(on: false);
				State = Health.Provisioning;
				return;
			}
			AuditOccupants();
			if (State == Health.Failed)
			{
				return;
			}
			Recorder privateRecorder = instance.PrivateRecorder;
			if ((Object)(object)privateRecorder != (Object)null && privateRecorder.RecordingEnabled)
			{
				if (privateRecorder.InterestGroup != 0)
				{
					privateRecorder.InterestGroup = 0;
				}
				if (privateRecorder.TargetPlayers != null)
				{
					privateRecorder.TargetPlayers = null;
				}
			}
			SetPrivateTransmit(GameMicAllows() && !PrivateVoiceLocalPrefs.MicMuted);
			State = Health.Live;
		}

		private static void AuditOccupants()
		{
			PrivateVoiceClient? instance = PrivateVoiceClient.Instance;
			object obj;
			if (instance == null)
			{
				obj = null;
			}
			else
			{
				LoadBalancingTransport client = ((VoiceConnection)instance).Client;
				if (client == null)
				{
					obj = null;
				}
				else
				{
					Room currentRoom = ((LoadBalancingClient)client).CurrentRoom;
					obj = ((currentRoom != null) ? currentRoom.Players : null);
				}
			}
			Dictionary<int, Player> dictionary = (Dictionary<int, Player>)obj;
			if (dictionary == null)
			{
				return;
			}
			PlayerRegistry instance2 = PlayerRegistry.Instance;
			if (instance2 == null)
			{
				return;
			}
			int[] array = PrivateVoiceChannel.MemberActors();
			for (int i = 0; i < array.Length; i++)
			{
				if (instance2.TryGetSteamId(array[i]) == null)
				{
					return;
				}
			}
			bool flag = false;
			foreach (KeyValuePair<int, Player> item in dictionary)
			{
				Player value = item.Value;
				if (value == null || value.IsLocal || value.IsInactive)
				{
					continue;
				}
				string userId = value.UserId;
				if (string.IsNullOrEmpty(userId))
				{
					continue;
				}
				bool flag2 = false;
				for (int j = 0; j < array.Length; j++)
				{
					if (instance2.TryGetSteamId(array[j]) == userId)
					{
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				unexpectedOccupantFirstSeenAt = -1f;
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (unexpectedOccupantFirstSeenAt < 0f)
			{
				unexpectedOccupantFirstSeenAt = realtimeSinceStartup;
			}
			else if (!(realtimeSinceStartup - unexpectedOccupantFirstSeenAt < 2f))
			{
				Plugin.Logger.LogWarning((object)"Private voice: unexpected occupant persisted - muting the private channel");
				SetPrivateTransmit(on: false);
				State = Health.Failed;
			}
		}

		private static bool GameMicAllows()
		{
			PlayerVoiceChat instance = PlayerVoiceChat.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			if (!instance.microphoneEnabled)
			{
				return false;
			}
			if ((Object)(object)DataDirector.instance == (Object)null)
			{
				return false;
			}
			if (DataDirector.instance.toggleMute)
			{
				return false;
			}
			if ((Object)(object)AudioManager.instance == (Object)null)
			{
				return false;
			}
			if (AudioManager.instance.pushToTalk && !SemiFunc.InputHold((InputKey)25))
			{
				return false;
			}
			return true;
		}

		private static float GameVolume()
		{
			if ((Object)(object)DataDirector.instance == (Object)null)
			{
				return 1f;
			}
			float num = (float)DataDirector.instance.SettingValueFetch((Setting)13) * 0.01f;
			float num2 = (float)DataDirector.instance.SettingValueFetch((Setting)4) * 0.01f;
			float num3 = num * num2;
			if (num3 < 0f)
			{
				num3 = 0f;
			}
			if (num3 > 1f)
			{
				num3 = 1f;
			}
			return num3;
		}

		private static void SetPrivateTransmit(bool on)
		{
			Recorder val = PrivateVoiceClient.Instance?.PrivateRecorder;
			if ((Object)(object)val != (Object)null && val.TransmitEnabled != on)
			{
				val.TransmitEnabled = on;
			}
		}

		private static void ForceGameRecorderOff()
		{
			PlayerVoiceChat instance = PlayerVoiceChat.instance;
			if (!((Object)(object)instance == (Object)null))
			{
				Recorder component = ((Component)instance).GetComponent<Recorder>();
				if ((Object)(object)component != (Object)null)
				{
					RecorderTransmitPatch.ForceOff(component);
				}
			}
		}

		internal static void TearDown(string reason)
		{
			if (provisionedRoom.Length != 0 || State != Health.Off)
			{
				Plugin.Logger.LogInfo((object)("Private voice: tearing down (" + reason + ")"));
				SetPrivateTransmit(on: false);
				PrivateVoiceClient.Instance?.TearDown();
				provisionedRoom = string.Empty;
				lastVoiceJoined = false;
				unexpectedOccupantFirstSeenAt = -1f;
				State = Health.Off;
				releaseAt = Time.realtimeSinceStartup + 0.3f;
			}
		}
	}
	internal static class PrivateVoiceLocalPrefs
	{
		internal const int MaxVolumePercent = 300;

		internal static int VolumePercent => ModConfig.PrivateChannelVolume.Value;

		internal static bool Muted { get; private set; }

		internal static bool MicMuted { get; private set; }

		internal static float Factor
		{
			get
			{
				if (!Muted)
				{
					return (float)VolumePercent * 0.01f;
				}
				return 0f;
			}
		}

		internal static void SetVolumePercent(int value)
		{
			int num = ((value >= 0) ? ((value > 300) ? 300 : value) : 0);
			if (ModConfig.PrivateChannelVolume.Value != num)
			{
				ModConfig.PrivateChannelVolume.Value = num;
			}
		}

		internal static void ToggleMuted()
		{
			Muted = !Muted;
		}

		internal static void ToggleMicMuted()
		{
			MicMuted = !MicMuted;
		}
	}
	internal static class PrivateVoiceDsp
	{
		internal static void Mirror(GameObject recorderObject)
		{
			PlayerVoiceChat instance = PlayerVoiceChat.instance;
			WebRtcAudioDsp val = (((Object)(object)instance != (Object)null) ? ((Component)instance).GetComponent<WebRtcAudioDsp>() : null);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"Private voice: the game's recorder carries no WebRtcAudioDsp - the private stream keeps the raw microphone level and will stay quieter than the public channel");
				return;
			}
			if (MicTee.Channels != 1)
			{
				Plugin.Logger.LogWarning((object)$"Private voice: capture is {MicTee.Channels} ch and WebRtcAudioDsp is mono-only - the DSP mirror is skipped and the private stream keeps the raw microphone level");
				return;
			}
			WebRtcAudioDsp val2 = recorderObject.AddComponent<WebRtcAudioDsp>();
			val2.AEC = val.AEC;
			val2.AecHighPass = val.AecHighPass;
			val2.ReverseStreamDelayMs = val.ReverseStreamDelayMs;
			val2.HighPass = val.HighPass;
			val2.NoiseSuppression = val.NoiseSuppression;
			val2.AGC = val.AGC;
			val2.AgcCompressionGain = val.AgcCompressionGain;
			val2.AgcTargetLevel = val.AgcTargetLevel;
			val2.Bypass = val.Bypass;
			val2.VAD = false;
			Plugin.Logger.LogInfo((object)$"Private voice: DSP mirrored from the game's recorder (AGC {OnOff(val2.AGC)} target {val2.AgcTargetLevel} dBFS / compression {val2.AgcCompressionGain} dB, noise suppression {OnOff(val2.NoiseSuppression)}, high pass {OnOff(val2.HighPass)}, AEC {OnOff(val2.AEC)}, VAD off by design, bypass {OnOff(val2.Bypass)})");
		}

		private static string OnOff(bool value)
		{
			if (!value)
			{
				return "off";
			}
			return "on";
		}
	}
	internal sealed class TeeAudioReader : IAudioReader<float>, IDataReader<float>, IDisposable, IAudioDesc
	{
		public int SamplingRate => MicTee.SamplingRate;

		public int Channels => MicTee.Channels;

		public string? Error
		{
			get
			{
				if (!MicTee.IsLive)
				{
					return "mic tee not live";
				}
				return null;
			}
		}

		public bool Read(float[] buffer)
		{
			return MicTee.Ring.Read(buffer);
		}

		public void Dispose()
		{
		}
	}
}
namespace SharePermissions.UI
{
	internal static class ColorPickerPage
	{
		private const float ContentWidth = 250f;

		private const float SwatchSize = 34f;

		private const float SwatchPitch = 38f;

		private const int SwatchesPerRow = 6;

		private static readonly IReadOnlyList<Color> FallbackPalette = (IReadOnlyList<Color>)(object)new Color[16]
		{
			ModStyle.RoleHost,
			ModStyle.RoleModerator,
			ModStyle.RoleModUser,
			ModStyle.RoleNone,
			ModStyle.SevBan,
			ModStyle.SevRevoke,
			ModStyle.SevGrant,
			ModStyle.SevFlood,
			Color.white,
			Color.red,
			Color.green,
			Color.blue,
			Color.yellow,
			Color.cyan,
			Color.magenta,
			Color.gray
		};

		internal static void Open(string title, string description, Color current, Action<Color> onPicked, string? clearCaption = null, Action? onClear = null)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			REPOPopupPage page = MenuUiHelpers.CreatePage(title, delegate
			{
			});
			MenuUiHelpers.AddLabel(page, description);
			MenuUiHelpers.AddLabel(page, "<size=75%><color=#6f7d88>Current</color>  <color=#" + NameColors.ToHex(current) + ">#" + NameColors.ToHex(current) + "</color></size>");
			foreach (IReadOnlyList<Color> item in Rows(Palette()))
			{
				AddSwatchRow(page, item, Choose);
			}
			AddHexInput(page, current, Choose);
			if (onClear != null && clearCaption != null)
			{
				MenuUiHelpers.AddScrollViewButton(page, clearCaption, delegate
				{
					MenuUiHelpers.ClosePage(page);
					onClear();
				});
			}
			MenuUiHelpers.OpenPage(page);
			void Choose(Color color)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				MenuUiHelpers.ClosePage(page);
				onPicked(color);
			}
		}

		private static void AddSwatchRow(REPOPopupPage page, IReadOnlyList<Color> colors, Action<Color> onChoose)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Expected O, but got Unknown
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Expected O, but got Unknown
				//IL_0033: 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_0049: 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)
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject("SharePermissions_SwatchRow", new Type[1] { typeof(RectTransform) });
				RectTransform val2 = (RectTransform)val.transform;
				((Transform)val2).SetParent(scrollView, false);
				val2.anchorMin = Vector2.zero;
				val2.anchorMax = Vector2.zero;
				val2.pivot = Vector2.zero;
				val2.sizeDelta = new Vector2(250f, 34f);
				for (int i = 0; i < colors.Count; i++)
				{
					Color color = colors[i];
					REPOButton val3 = MenuAPI.CreateREPOButton("", (Action)delegate
					{
						//IL_000c: Unknown result type (might be due to invalid IL or missing references)
						onChoose(color);
					}, (Transform)(object)val2, new Vector2((float)i * 38f, 0f));
					val3.overrideButtonSize = new Vector2(34f, 34f);
					StyleSwatch(val3, color);
				}
				return val2;
			}, 0f, 2f);
		}

		private static void StyleSwatch(REPOButton button, Color color)
		{
			//IL_0011: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			Image component = ((Component)button).GetComponent<Image>();
			if ((Object)(object)component != (Object)null)
			{
				((Graphic)component).color = color;
				((Graphic)component).raycastTarget = true;
			}
			if (!((Object)(object)button.menuButton == (Object)null))
			{
				button.menuButton.resizeButton = false;
				button.menuButton.customColors = true;
				button.menuButton.colorNormal = NameColors.Dimmed(color, 0.75f);
				button.menuButton.colorHover = color;
				button.menuButton.colorClick = Color.Lerp(color, Color.white, 0.95f);
			}
		}

		private static void AddHexInput(REPOPopupPage page, Color current, Action<Color> onChoose)
		{
			//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)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
			{
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: 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)
				Action<string> obj = delegate(string value)
				{
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					if (NameColors.TryParseHex(value, out var color))
					{
						onChoose(color);
					}
					else
					{
						Plugin.Logger.LogInfo((object)("Name color ignored: '" + value + "' is not a #RRGGBB value"));
					}
				};
				string text = "#" + NameColors.ToHex(current);
				REPOInputField val = MenuAPI.CreateREPOInputField("Hex", obj, scrollView, default(Vector2), true, text, "");
				((TMP_Text)val.labelTMP).fontSize = 14f;
				return ((REPOElement)val).rectTransform;
			}, 4f, 2f);
			MenuUiHelpers.AddLabel(page, "<size=75%><color=#6f7d88>Or type a color as #RRGGBB and press enter.</color></size>");
		}

		private static IEnumerable<IReadOnlyList<Color>> Rows(IReadOnlyList<Color> colors)
		{
			for (int start = 0; start < colors.Count; start += 6)
			{
				yield return colors.Skip(start).Take(6).ToList();
			}
		}

		private static IReadOnlyList<Color> Palette()
		{
			try
			{
				IReadOnlyList<Color> readOnlyList = GamePaletteRaw();
				if (readOnlyList.Count > 0)
				{
					return readOnlyList;
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[SharePermissions] Game color palette unreadable, using the built-in one: " + ex.Message));
			}
			return FallbackPalette;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static IReadOnlyList<Color> GamePaletteRaw()
		{
			MetaManager instance = MetaManager.instance;
			if ((Object)(object)instance == (Object)null || instance.colors == null)
			{
				return Array.Empty<Color>();
			}
			List<SemiColor> order = instance.colorsUIOrder;
			return (from c in instance.colors
				where (Object)(object)c != (Object)null
				orderby (order != null) ? order.IndexOf(c) : 0
				select c.color).ToList();
		}
	}
	internal sealed class ExtrasPanelController
	{
		private readonly REPOPopupPage page;

		private REPOScrollViewElement? channelHeaderElem;

		private REPOLabel? offHint;

		private REPOScrollViewElement? offHintElem;

		private string offHintCache = string.Empty;

		private REPOScrollViewElement? announceHeaderElem;

		private REPOButton? privateToggle;

		private REPOScrollViewElement? privateToggleElem;

		private REPOLabel? privateStatus;

		private REPOScrollViewElement? privateStatusElem;

		private bool privateTalking;

		private float privateTalkHoldUntil;

		private PrivateVoiceDriver.Health lastStatusState = (PrivateVoiceDriver.Health)(-1);

		private bool lastStatusMicMuted;

		private bool lastStatusTransmitting;

		private bool lastStatusShowTalkDot;

		private REPOButton? micMuteButton;

		private REPOScrollViewElement? micMuteElem;

		private string micMuteCache = string.Empty;

		private REPOButton? soundMuteButton;

		private REPOScrollViewElement? soundMuteElem;

		private string soundMuteCache = string.Empty;

		private REPOSlider? privateVolumeSlider;

		private REPOScrollViewElement? privateVolumeSliderElem;

		private REPOLabel? hotkeyHint;

		private REPOScrollViewElement? hotkeyHintElem;

		private KeyCode lastHotkeyMicMuteKey = (KeyCode)(-1);

		private KeyCode lastHotkeyDeafenKey = (KeyCode)(-1);

		private REPOInputField? announceField;

		private REPOScrollViewElement? announceFieldElem;

		private REPOButton? announceBtn;

		private REPOScrollViewElement? announceBtnElem;

		private string announceDraft = "";

		private bool tabVisible;

		internal ExtrasPanelController(REPOPopupPage page)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			this.page = page;
		}

		internal void Build()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Expected O, but got Unknown
			channelHeaderElem = AddLabel("<size=115%>Private channel</size>");
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0024: 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_006b: Unknown result type (might be due to invalid IL or missing references)
				privateToggle = MenuAPI.CreateREPOButton("", (Action)ModerationActions.TogglePrivateVoice, sv, default(Vector2));
				((TMP_Text)privateToggle.labelTMP).richText = true;
				((TMP_Text)privateToggle.labelTMP).fontSize = 14f;
				privateToggle.overrideButtonSize = new Vector2(250f, 24f);
				return ((REPOElement)privateToggle).rectTransform;
			}, 0f, 2f);
			privateToggleElem = Elem((Component?)(object)privateToggle);
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0009: 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)
				offHint = MenuAPI.CreateREPOLabel("", sv, default(Vector2));
				((TMP_Text)offHint.labelTMP).richText = true;
				((TMP_Text)offHint.labelTMP).fontSize = 14f;
				return ((REPOElement)offHint).rectTransform;
			}, 0f, 6f);
			offHintElem = Elem((Component?)(object)offHint);
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0009: 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)
				privateStatus = MenuAPI.CreateREPOLabel("", sv, default(Vector2));
				((TMP_Text)privateStatus.labelTMP).richText = true;
				((TMP_Text)privateStatus.labelTMP).fontSize = 14f;
				return ((REPOElement)privateStatus).rectTransform;
			}, 0f, 2f);
			privateStatusElem = Elem((Component?)(object)privateStatus);
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0024: 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_006b: Unknown result type (might be due to invalid IL or missing references)
				micMuteButton = MenuAPI.CreateREPOButton("", (Action)OnMicMuteClicked, sv, default(Vector2));
				((TMP_Text)micMuteButton.labelTMP).richText = true;
				((TMP_Text)micMuteButton.labelTMP).fontSize = 14f;
				micMuteButton.overrideButtonSize = new Vector2(250f, 24f);
				return ((REPOElement)micMuteButton).rectTransform;
			}, 0f, 2f);
			micMuteElem = Elem((Component?)(object)micMuteButton);
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0024: 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_006b: Unknown result type (might be due to invalid IL or missing references)
				soundMuteButton = MenuAPI.CreateREPOButton("", (Action)OnSoundMuteClicked, sv, default(Vector2));
				((TMP_Text)soundMuteButton.labelTMP).richText = true;
				((TMP_Text)soundMuteButton.labelTMP).fontSize = 14f;
				soundMuteButton.overrideButtonSize = new Vector2(250f, 24f);
				return ((REPOElement)soundMuteButton).rectTransform;
			}, 0f, 2f);
			soundMuteElem = Elem((Component?)(object)soundMuteButton);
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				Action<int> action = OnPrivateVolumeChanged;
				int volumePercent = PrivateVoiceLocalPrefs.VolumePercent;
				privateVolumeSlider = MenuAPI.CreateREPOSlider("Private volume", "", action, sv, default(Vector2), 0, 300, volumePercent, "", "%", (BarBehavior)0);
				return ((REPOElement)privateVolumeSlider).rectTransform;
			}, 0f, 2f);
			privateVolumeSliderElem = Elem((Component?)(object)privateVolumeSlider);
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0009: 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)
				hotkeyHint = MenuAPI.CreateREPOLabel("", sv, default(Vector2));
				((TMP_Text)hotkeyHint.labelTMP).richText = true;
				((TMP_Text)hotkeyHint.labelTMP).fontSize = 14f;
				return ((REPOElement)hotkeyHint).rectTransform;
			}, 0f, 6f);
			hotkeyHintElem = Elem((Component?)(object)hotkeyHint);
			announceHeaderElem = AddLabel("<size=115%>Announcements</size>");
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0015: 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)
				announceField = MenuAPI.CreateREPOInputField("Announce", (Action<string>)delegate(string v)
				{
					announceDraft = v ?? "";
				}, sv, default(Vector2), false, "message to everyone", "");
				((TMP_Text)announceField.labelTMP).fontSize = 14f;
				return ((REPOElement)announceField).rectTransform;
			}, 4f, 0f);
			announceFieldElem = Elem((Component?)(object)announceField);
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0015: 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)
				announceBtn = MenuAPI.CreateREPOButton("Send announcement", (Action)delegate
				{
					ModerationActions.SendAnnouncement(announceDraft);
				}, sv, default(Vector2));
				((TMP_Text)announceBtn.labelTMP).fontSize = 14f;
				return ((REPOElement)announceBtn).rectTransform;
			}, 0f, 2f);
			announceBtnElem = Elem((Component?)(object)announceBtn);
		}

		internal void SetTabVisible(bool visible)
		{
			tabVisible = visible;
			if (!visible)
			{
				SetVisibility(channelHeaderElem, visible: false);
				SetVisibility(privateToggleElem, visible: false);
				SetVisibility(offHintElem, visible: false);
				SetVisibility(privateStatusElem, visible: false);
				SetVisibility(micMuteElem, visible: false);
				SetVisibility(soundMuteElem, visible: false);
				SetVisibility(privateVolumeSliderElem, visible: false);
				SetVisibility(hotkeyHintElem, visible: false);
				SetVisibility(announceHeaderElem, visible: false);
				UnfocusAnnounceField();
				SetVisibility(announceFieldElem, visible: false);
				SetVisibility(announceBtnElem, visible: false);
			}
			else
			{
				Tick();
			}
		}

		private void UnfocusAnnounceField()
		{
			if ((Object)(object)announceField != (Object)null && (Object)(object)announceField.inputStringSystem != (Object)null)
			{
				announceField.inputStringSystem.isFocused = false;
			}
		}

		internal void Tick()
		{
			if (!((Object)(object)page == (Object)null) && tabVisible)
			{
				bool flag = SemiFunc.IsMasterClient();
				bool localActive = PrivateVoiceChannel.LocalActive;
				SetVisibility(channelHeaderElem, visible: true);
				SetVisibility(privateToggleElem, flag);
				SetVisibility(offHintElem, !flag && !localActive);
				SetVisibility(privateStatusElem, localActive);
				SetVisibility(micMuteElem, localActive);
				SetVisibility(soundMuteElem, localActive);
				SetVisibility(privateVolumeSliderElem, localActive);
				SetVisibility(hotkeyHintElem, localActive);
				SetVisibility(announceHeaderElem, flag);
				SetVisibility(announceFieldElem, flag);
				SetVisibility(announceBtnElem, flag);
				if (flag)
				{
					UpdateChannelToggle();
				}
				if (!flag && !localActive)
				{
					UpdateOffHint();
				}
				if (localActive)
				{
					UpdateStatus();
					UpdateMuteCaptions();
					UpdateHotkeyHint();
				}
				else
				{
					lastStatusState = (PrivateVoiceDriver.Health)(-1);
				}
			}
		}

		private void UpdateChannelToggle()
		{
			if (!((Object)(object)privateToggle == (Object)null))
			{
				string text = (PrivateVoiceChannel.Active ? "Private channel: <color=#4dd07a>ON</color>" : "Private channel: <color=#6f7d88>OFF</color>");
				if (((TMP_Text)privateToggle.labelTMP).text != text)
				{
					((TMP_Text)privateToggle.labelTMP).text = text;
				}
			}
		}

		private void UpdateOffHint()
		{
			if (!((Object)(object)offHint == (Object)null))
			{
				string text = "<size=75%><color=#6f7d88>Off - the host opens the private channel.</color></size>";
				if (!(text == offHintCache))
				{
					offHintCache = text;
					((TMP_Text)offHint.labelTMP).text = text;
					MenuUiHelpers.SizeWrappedLabel(offHint, text, 250f);
				}
			}
		}

		private void UpdateStatus()
		{
			if (!((Object)(object)privateStatus == (Object)null))
			{
				float realtimeSinceStartup = Time.realtimeSinceStartup;
				PrivateVoiceClient instance = PrivateVoiceClient.Instance;
				bool flag = (Object)(object)instance != (Object)null && (Object)(object)instance.PrivateRecorder != (Object)null && instance.PrivateRecorder.TransmitEnabled;
				if (MicTee.Level > 0.005f)
				{
					privateTalking = true;
					privateTalkHoldUntil = realtimeSinceStartup + 0.18f;
				}
				else if (realtimeSinceStartup >= privateTalkHoldUntil)
				{
					privateTalking = false;
				}
				bool flag2 = privateTalking && flag && PrivateVoiceDriver.State == PrivateVoiceDriver.Health.Live;
				PrivateVoiceDriver.Health state = PrivateVoiceDriver.State;
				bool micMuted = PrivateVoiceLocalPrefs.MicMuted;
				if (state != lastStatusState || micMuted != lastStatusMicMuted || flag != lastStatusTransmitting || flag2 != lastStatusShowTalkDot)
				{
					lastStatusState = state;
					lastStatusMicMuted = micMuted;
					lastStatusTransmitting = flag;
					lastStatusShowTalkDot = flag2;
					string text = "Private voice: " + state switch
					{
						PrivateVoiceDriver.Health.Live => (!micMuted) ? (flag ? "<color=#4dd07a>live</color>" : "<color=#6f7d88>muted</color>") : "<color=#ef5350>mic off</color>", 
						PrivateVoiceDriver.Health.Listening => "<color=#4dd07a>listening</color>", 
						PrivateVoiceDriver.Health.Provisioning => "<color=#e0b84d>connecting</color>", 
						PrivateVoiceDriver.Health.Failed => "<color=#ef5350>failed</color>", 
						_ => "<color=#6f7d88>off</color>", 
					} + (flag2 ? "  <color=#d9e8a8>●</color>" : string.Empty);
					((TMP_Text)privateStatus.labelTMP).text = text;
					MenuUiHelpers.SizeWrappedLabel(privateStatus, text, 250f);
				}
			}
		}

		private void UpdateMuteCaptions()
		{
			if ((Object)(object)micMuteButton != (Object)null)
			{
				string text = (PrivateVoiceLocalPrefs.MicMuted ? "Microphone: <color=#ef5350>MUTED</color>" : "Microphone: <color=#4dd07a>LIVE</color>");
				if (text != micMuteCache)
				{
					micMuteCache = text;
					((TMP_Text)micMuteButton.labelTMP).text = text;
				}
			}
			if ((Object)(object)soundMuteButton != (Object)null)
			{
				string text2 = (PrivateVoiceLocalPrefs.Muted ? "Sound: <color=#ef5350>MUTED</color>" : "Sound: <color=#4dd07a>ON</color>");
				if (text2 != soundMuteCache)
				{
					soundMuteCache = text2;
					((TMP_Text)soundMuteButton.labelTMP).text = text2;
				}
			}
		}

		private void UpdateHotkeyHint()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: 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_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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: 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 (!((Object)(object)hotkeyHint == (Object)null))
			{
				KeyCode value = ModConfig.PrivateMicMuteKey.Value;
				KeyCode value2 = ModConfig.PrivateDeafenKey.Value;
				if (value != lastHotkeyMicMuteKey || value2 != lastHotkeyDeafenKey)
				{
					lastHotkeyMicMuteKey = value;
					lastHotkeyDeafenKey = value2;
					string text = "<size=75%><color=#6f7d88>Mic mute: " + KeyName(value) + "   Sound mute: " + KeyName(value2) + "   Both are local and reset when the game closes.</color></size>";
					((TMP_Text)hotkeyHint.labelTMP).text = text;
					MenuUiHelpers.SizeWrappedLabel(hotkeyHint, text, 250f);
				}
			}
		}

		private unsafe static string KeyName(KeyCode key)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if ((int)key != 0)
			{
				return ((object)(*(KeyCode*)(&key))/*cast due to .constrained prefix*/).ToString();
			}
			return "unbound";
		}

		private static void OnMicMuteClicked()
		{
			PrivateVoiceLocalPrefs.ToggleMicMuted();
		}

		private static void OnSoundMuteClicked()
		{
			PrivateVoiceLocalPrefs.ToggleMuted();
		}

		private static void OnPrivateVolumeChanged(int percent)
		{
			PrivateVoiceLocalPrefs.SetVolumePercent(percent);
		}

		private REPOScrollViewElement? AddLabel(string richText)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			REPOLabel made = null;
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0009: 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)
				REPOLabel val = MenuAPI.CreateREPOLabel(richText, sv, default(Vector2));
				((TMP_Text)val.labelTMP).richText = true;
				((TMP_Text)val.labelTMP).fontSize = 14f;
				MenuUiHelpers.SizeWrappedLabel(val, richText, 250f);
				made = val;
				return ((REPOElement)val).rectTransform;
			}, 0f, 6f);
			return Elem((Component?)(object)made);
		}

		private static REPOScrollViewElement? Elem(Component? made)
		{
			if (!((Object)(object)made == (Object)null))
			{
				return made.GetComponent<REPOScrollViewElement>();
			}
			return null;
		}

		private static void SetVisibility(REPOScrollViewElement? elem, bool visible)
		{
			if ((Object)(object)elem != (Object)null)
			{
				elem.visibility = visible;
			}
		}
	}
	internal sealed class GhostRowDriver : MonoBehaviour
	{
		private static readonly Color TalkNameColor = new Color(0.6f, 0.6f, 0.4f);

		internal static readonly Color IdleNameColor = new Color(0.2f, 0.2f, 0.2f);

		private const float ColorLerpSpeed = 10f;

		private const float TalkThreshold = 0.005f;

		private const float HoldTime = 0.18f;

		private const float WobbleDegreesPerLoudness = 200f;

		private const float FocusPushAlong = 12.5f;

		private const float FocusPushPerp = 6f;

		private const float EyeRestX = 50f;

		private const float EyeRestY = 25f;

		private const float EyeNudge = 10f;

		private const float EyeLerpSpeed = 10f;

		private const float CursorFocusOffsetX = 18f;

		private const float CursorFocusOffsetY = 15f;

		private int actorNumber;

		private MenuPlayerListed? row;

		private TextMeshProUGUI? playerName;

		private MenuPlayerHead? head;

		private RectTransform? rowRect;

		private RectTransform? headRect;

		private RectTransform? headTransform;

		private RectTransform? eyesTransform;

		private bool facingRight = true;

		private int listSpotPrev = -1;

		private float talkUntil;

		internal void Initialize(int actor)
		{
			actorNumber = actor;
		}

		private void Awake()
		{
			row = ((Component)this).GetComponent<MenuPlayerListed>();
			if ((Object)(object)row != (Object)null)
			{
				playerName = row.playerName;
				head = row.playerHead;
				rowRect = ((Component)row).GetComponent<RectTransform>();
				if ((Object)(object)head != (Object)null)
				{
					headRect = ((Component)head).GetComponent<RectTransform>();
				}
			}
		}

		private void Update()
		{
			float loud = ReadLoudness();
			bool talking = UpdateTalkHold(loud);
			PublishTalkState(talking);
			if ((Object)(object)row != (Object)null)
			{
				ApplyFacing(row.listSpot);
			}
			ApplyWobble(loud);
			UpdateNameColor(talking);
			SyncEyeContact();
		}

		private void SyncEyeContact()
		{
			try
			{
				SyncFocusPoint();
				SyncCursorFocus();
				SyncEyes();
			}
			catch
			{
			}
		}

		private float ReadLoudness()
		{
			return VoiceChatPatch.AmplitudeFor(actorNumber);
		}

		private bool UpdateTalkHold(float loud)
		{
			if (loud > 0.005f)
			{
				talkUntil = Time.time + 0.18f;
			}
			return Time.time < talkUntil;
		}

		private void PublishTalkState(bool talking)
		{
			if (!((Object)(object)head == (Object)null))
			{
				if (ShouldStampTalkStart(talking, head.isTalking))
				{
					head.startedTalkingAtTime = Time.time;
				}
				head.isTalking = talking;
			}
		}

		private void ApplyWobble(float loud)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)headTransform == (Object)null))
			{
				((Transform)headTransform).localEulerAngles = new Vector3(0f, 0f, facingRight ? (loud * 200f) : ((0f - loud) * 200f));
			}
		}

		private void UpdateNameColor(bool talking)
		{
			//IL_001b: 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_0023: 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)
			if (!((Object)(object)playerName == (Object)null))
			{
				((Graphic)playerName).color = Color.Lerp(((Graphic)playerName).color, talking ? TalkNameColor : IdleNameColor, Time.deltaTime * 10f);
			}
		}

		private static bool ShouldStampTalkStart(bool talkingNow, bool wasTalking)
		{
			if (talkingNow)
			{
				return !wasTalking;
			}
			return false;
		}

		private static bool FacingIsRight(int listSpot)
		{
			return listSpot % 2 == 0;
		}

		private void ApplyFacing(int listSpot)
		{
			if (listSpot == listSpotPrev || (Object)(object)head == (Object)null)
			{
				return;
			}
			listSpotPrev = listSpot;
			facingRight = FacingIsRight(listSpot);
			Transform val = (facingRight ? head.headRight : head.headLeft);
			Transform val2 = (facingRight ? head.headLeft : head.headRight);
			if (!((Object)(object)val == (Object)null))
			{
				if ((Object)(object)val2 != (Object)null)
				{
					((Component)val2).gameObject.SetActive(false);
				}
				((Component)val).gameObject.SetActive(true);
				headTransform = ((Component)val).GetComponent<RectTransform>();
				Transform val3 = val.Find("Eyes");
				eyesTransform = (((Object)(object)val3 != (Object)null) ? ((Component)val3).GetComponent<RectTransform>() : null);
			}
		}

		private void SyncFocusPoint()
		{
			//IL_0053: 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)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)head == (Object)null) && !((Object)(object)head.focusPoint == (Object)null) && !((Object)(object)headTransform == (Object)null) && !((Object)(object)rowRect == (Object)null) && !((Object)(object)headRect == (Object)null))
			{
				Vector3 val = ((Transform)rowRect).localPosition + ((Transform)headRect).localPosition + ((Transform)headTransform).localPosition * ((Transform)headRect).localScale.x;
				float z = ((Transform)headTransform).localEulerAngles.z;
				float num = (facingRight ? 12.5f : (-12.5f));
				val += new Vector3(MenuPlayerHead.LengthDirX(num, z), MenuPlayerHead.LengthDirY(num, z), 0f);
				val += new Vector3(MenuPlayerHead.LengthDirX(6f, z + 90f), MenuPlayerHead.LengthDirY(6f, z + 90f), 0f);
				((Transform)head.focusPoint).localPosition = val;
			}
		}

		private void SyncEyes()
		{
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: 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)
			if ((Object)(object)head == (Object)null || (Object)(object)eyesTransform == (Object)null || (Object)(object)head.focusPoint == (Object)null || (Object)(object)head.myFocusPoint == (Object)null)
			{
				return;
			}
			MenuPlayerHead val = null;
			float num = 0f;
			List<MenuPlayerHead> list = (((Object)(object)MenuManager.instance != (Object)null) ? MenuManager.instance.playerHeads : null);
			if (list != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					MenuPlayerHead val2 = list[i];
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val2 == (Object)(object)head) && val2.isTalking && val2.startedTalkingAtTime > num)
					{
						num = val2.startedTalkingAtTime;
						val = val2;
					}
				}
			}
			Vector3 val3 = (((Object)(object)val != (Object)null && (Object)(object)val.focusPoint != (Object)null) ? ((Transform)val.focusPoint).localPosition : ((Transform)head.myFocusPoint).localPosition);
			Vector3 val4 = val3 - ((Transform)head.focusPoint).localPosition;
			val4.z = 0f;
			Vector3 val5 = new Vector3(facingRight ? 50f : (-50f), 25f, 0f) + ((Vector3)(ref val4)).normalized * 10f;
			((Transform)eyesTransform).localPosition = Vector3.Lerp(((Transform)eyesTransform).localPosition, val5, Time.deltaTime * 10f);
		}

		private void SyncCursorFocus()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)head == (Object)null) && !((Object)(object)head.myFocusPoint == (Object)null) && !((Object)(object)MenuManager.instance == (Object)null) && (int)MenuManager.instance.currentMenuPageIndex == 8 && !((Object)(object)MenuCursor.instance == (Object)null) && !((Object)(object)headRect == (Object)null) && !((Object)(object)((Transform)headRect).parent == (Object)null) && !((Object)(object)((Transform)headRect).parent.parent == (Object)null))
			{
				Vector3 val = ((Component)MenuCursor.instance).transform.localPosition - ((Transform)headRect).parent.parent.localPosition;
				((Transform)head.myFocusPoint).localPosition = new Vector3(val.x + 18f, val.y + 15f, 0f);
			}
		}
	}
	internal sealed class HeadMarkerComponent : MonoBehaviour
	{
		private const float AppearSeconds = 0.35f;

		private float spinDegreesPerSecond;

		private float pulsePeriodSeconds;

		private float bobAmplitude;

		private float bobPeriodSeconds;

		private Material? pulseMaterial;

		private Color baseColor;

		private bool emissionAvailable;

		private Vector3 basePosition;

		private float appearElapsed;

		private const float GlintSeconds = 0.25f;

		private Material? glintMaterial;

		private float glintPeriodSeconds;

		private float nextGlintAt;

		private float glintStartedAt = float.NegativeInfinity;

		private bool glintAvailable;

		private bool glintWasActive;

		private Color glintBaseEmission;

		private Material?[]? ownedMaterials;

		private bool materialsDestroyed;

		internal void Initialize(Material? material, Color color, float spinDps, float pulsePeriod, float bobAmp, float bobPeriod, Material? glintMat = null, float glintPeriod = 0f)
		{
			//IL_0008: 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_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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			pulseMaterial = material;
			baseColor = color;
			spinDegreesPerSecond = spinDps;
			pulsePeriodSeconds = pulsePeriod;
			bobAmplitude = bobAmp;
			bobPeriodSeconds = bobPeriod;
			basePosition = ((Component)this).transform.localPosition;
			if ((Object)(object)material != (Object)null && material.HasProperty("_EmissionColor"))
			{
				material.EnableKeyword("_EMISSION");
				emissionAvailable = true;
			}
			glintMaterial = glintMat;
			glintPeriodSeconds = glintPeriod;
			if ((Object)(object)glintMat != (Object)null && glintPeriod > 0f && glintMat.HasProperty("_EmissionColor"))
			{
				glintMat.EnableKeyword("_EMISSION");
				glintBaseEmission = glintMat.GetColor("_EmissionColor");
				glintAvailable = true;
				nextGlintAt = Time.time + glintPeriod * Random.Range(0.7f, 1.3f);
			}
		}

		internal void TakeOwnership(params Material?[] mats)
		{
			ownedMaterials = mats;
		}

		internal void DestroyOwnedMaterials()
		{
			if (materialsDestroyed || ownedMaterials == null)
			{
				return;
			}
			materialsDestroyed = true;
			Material[] array = ownedMaterials;
			foreach (Material val in array)
			{
				if ((Object)(object)val != (Object)null)
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		private void OnDestroy()
		{
			DestroyOwnedMaterials();
		}

		private void OnEnable()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			appearElapsed = 0f;
			((Component)this).transform.localScale = Vector3.zero;
			if (glintAvailable)
			{
				nextGlintAt = Time.time + glintPeriodSeconds * Random.Range(0.7f, 1.3f);
			}
		}

		private void Update()
		{
			//IL_003d: 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_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			if (appearElapsed < 0.35f)
			{
				appearElapsed += Time.deltaTime;
				float num = Mathf.Clamp01(appearElapsed / 0.35f) - 1f;
				((Component)this).transform.localScale = Vector3.one * (1f + 2.70158f * num * num * num + 1.70158f * num * num);
			}
			if (spinDegreesPerSecond != 0f)
			{
				((Component)this).transform.Rotate(0f, spinDegreesPerSecond * Time.deltaTime, 0f, (Space)0);
			}
			if (bobAmplitude > 0f)
			{
				float num2 = bobAmplitude * Mathf.Sin(Time.time * (MathF.PI * 2f / bobPeriodSeconds));
				((Component)this).transform.localPosition = basePosition + new Vector3(0f, num2, 0f);
			}
			if (emissionAvailable && (Object)(object)pulseMaterial != (Object)null)
			{
				float num3 = 1.05f + 0.45f * Mathf.Sin(Time.time * (MathF.PI * 2f / pulsePeriodSeconds));
				pulseMaterial.SetColor("_EmissionColor", baseColor * num3);
			}
			if (glintAvailable && (Object)(object)glintMaterial != (Object)null)
			{
				if (Time.time >= nextGlintAt)
				{
					glintStartedAt = Time.time;
					nextGlintAt = Time.time + glintPeriodSeconds * Random.Range(0.7f, 1.3f);
				}
				float num4 = (Time.time - glintStartedAt) / 0.25f;
				if (num4 < 1f)
				{
					glintWasActive = true;
					float num5 = Mathf.SmoothStep(0f, 1f, (num4 < 0.5f) ? (num4 * 2f) : (2f - num4 * 2f));
					Color val = (((Object)(object)glintMaterial == (Object)(object)pulseMaterial && emissionAvailable) ? (baseColor * (1.05f + 0.45f * Mathf.Sin(Time.time * (MathF.PI * 2f / pulsePeriodSeconds)))) : glintBaseEmission);
					glintMaterial.SetColor("_EmissionColor", Color.Lerp(val, Color.white * 1.6f, num5));
				}
				else if (glintWasActive)
				{
					glintWasActive = false;
					if ((Object)(object)glintMaterial != (Object)(object)pulseMaterial)
					{
						glintMaterial.SetColor("_EmissionColor", glintBaseEmission);
					}
				}
			}
			if (appearElapsed >= 0.35f && spinDegreesPerSecond == 0f && bobAmplitude <= 0f && !emissionAvailable && !glintAvailable)
			{
				((Behaviour)this).enabled = false;
			}
		}
	}
	internal static class HeadMarkers
	{
		internal const string CrownName = "SharePermissions_HostCrown";

		internal const string GemName = "SharePermissions_ModGem";

		internal const string DiamondName = "SharePermissions_ModUserDiamond";

		private static readonly Color GoldColor = new Color(0.95f, 0.76f, 0.31f);

		private static readonly Color RubyColor = new Color(0.85f, 0.2f, 0.28f);

		private static readonly Color ModUserColor = new Color(0.5f, 0.54f, 0.63f);

		private const float BandOuterRadius = 0.075f;

		private const float BandInnerRadius = 0.058f;

		private const float BandHeight = 0.03f;

		private const int CrownPoints = 8;

		private static Mesh? bandMesh;

		private static Mesh? tallSpikeMesh;

		private static Mesh? shortSpikeMesh;

		private static Mesh? jewelMesh;

		private static Mesh? gemMesh;

		private static Mesh? diamondMesh;

		private static Mesh BandMesh => bandMesh ?? (bandMesh = MarkerMeshes.Band(16, 0.075f, 0.058f, 0.03f));

		private static Mesh TallSpikeMesh => tallSpikeMesh ?? (tallSpikeMesh = MarkerMeshes.Pyramid(0.016f, 0.075f, 6));

		private static Mesh ShortSpikeMesh => shortSpikeMesh ?? (shortSpikeMesh = MarkerMeshes.Pyramid(0.013f, 0.048f, 6));

		private static Mesh JewelMesh => jewelMesh ?? (jewelMesh = MarkerMeshes.Bipyramid(6, 0.01f, 0.01f, 0.01f));

		private static Mesh GemMesh => gemMesh ?? (gemMesh = MarkerMeshes.GemCut(10, 0.05f, 0.028f, 0.032f, 0.068f));

		private static Mesh DiamondMesh => diamondMesh ?? (diamondMesh = MarkerMeshes.GemCut(8, 0.032f, 0.018f, 0.02f, 0.042f));

		internal static Transform BuildCrown(Transform attach)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_002d: 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_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SharePermissions_HostCrown");
			val.transform.SetParent(attach, false);
			val.transform.localPosition = new Vector3(0f, 0.2f, 0f);
			Material val2 = NewMaterial(GoldColor, 0.9f, 0.78f);
			Material val3 = NewMaterial(RubyColor, 0.3f, 0.9f, 0.75f);
			AddMesh(val.transform, val2, BandMesh);
			float num = 0.0665f;
			Vector3 val4 = default(Vector3);
			for (int i = 0; i < 8; i++)
			{
				float num2 = (float)i / 8f * MathF.PI * 2f;
				((Vector3)(ref val4))..ctor(Mathf.Cos(num2), 0f, Mathf.Sin(num2));
				bool flag = (i & 1) == 0;
				AddMesh(val.transform, val2, flag ? TallSpikeMesh : ShortSpikeMesh, val4 * num + Vector3.up * 0.015f);
				if (flag)
				{
					AddMesh(val.transform, val3, JewelMesh, val4 * 0.075f);
				}
			}
			HeadMarkerComponent headMarkerComponent = val.AddComponent<HeadMarkerComponent>();
			headMarkerComponent.Initialize(val2, GoldColor, 40f, 1.6f, 0f, 0f, val3, 4.5f);
			headMarkerComponent.TakeOwnership(val2, val3);
			val.SetActive(false);
			return val.transform;
		}

		internal static Transform BuildGem(Transform attach)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_002d: 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_005f: 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)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SharePermissions_ModGem");
			val.transform.SetParent(attach, false);
			val.transform.localPosition = new Vector3(0f, 0.18f, 0f);
			Material val2 = NewMaterial(Moderators.ModeratorColor, 0.25f, 0.92f, 0.25f);
			AddMesh(val.transform, val2, GemMesh);
			HeadMarkerComponent headMarkerComponent = val.AddComponent<HeadMarkerComponent>();
			headMarkerComponent.Initialize(val2, Moderators.ModeratorColor, 60f, 1.8f, 0.012f, 2.6f, val2, 6f);
			headMarkerComponent.TakeOwnership(val2);
			val.SetActive(false);
			return val.transform;
		}

		internal static Transform BuildDiamond(Transform attach)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_002d: 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_005f: 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)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("SharePermissions_ModUserDiamond");
			val.transform.SetParent(attach, false);
			val.transform.localPosition = new Vector3(0f, 0.16f, 0f);
			Material val2 = NewMaterial(ModUserColor, 0.1f, 0.65f, 0.12f);
			AddMesh(val.transform, val2, DiamondMesh);
			HeadMarkerComponent headMarkerComponent = val.AddComponent<HeadMarkerComponent>();
			headMarkerComponent.Initialize(null, ModUserColor, 0f, 0f, 0f, 0f);
			headMarkerComponent.TakeOwnership(val2);
			val.SetActive(false);
			return val.transform;
		}

		private static GameObject AddMesh(Transform parent, Material mat, Mesh mesh, Vector3 localPos = default(Vector3))
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("facet");
			val.transform.SetParent(parent, false);
			val.transform.localPosition = localPos;
			val.AddComponent<MeshFilter>().sharedMesh = mesh;
			((Renderer)val.AddComponent<MeshRenderer>()).sharedMaterial = mat;
			return val;
		}

		private static Material NewMaterial(Color color, float metallic, float smoothness, float staticGlow = 0f)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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)
			Shader val = Shader.Find("Standard") ?? Shader.Find("Sprites/Default") ?? Shader.Find("Hidden/InternalErrorShader");
			Material val2 = new Material(val);
			val2.color = color;
			if (val2.HasProperty("_Metallic"))
			{
				val2.SetFloat("_Metallic", metallic);
			}
			if (val2.HasProperty("_Glossiness"))
			{
				val2.SetFloat("_Glossiness", smoothness);
			}
			if (staticGlow > 0f && val2.HasProperty("_EmissionColor"))
			{
				val2.EnableKeyword("_EMISSION");
				val2.SetColor("_EmissionColor", color * staticGlow);
			}
			return val2;
		}
	}
	internal sealed class HistoryPageController
	{
		private const int PageSize = 10;

		private const int DetailRows = 20;

		private const float DetailWidth = 250f;

		private const int ColPrev = 0;

		private const int ColPage = 1;

		private const int ColNext = 2;

		private const int BandColumns = 5;

		private static readonly Vector2 BandPos = new Vector2(ModStyle.BandLeft, 20f);

		private static readonly string[] FacetLabels = new string[6] { "All", "Kicks & bans", "Flood", "Mute", "Moderator", "Info" };

		private readonly REPOPopupPage page;

		private readonly IReadOnlyList<string> entries;

		private readonly List<int> view = new List<int>();

		private int pageIndex;

		private string searchText = "";

		private int facetIndex;

		private int initiatorIndex;

		private readonly List<string?> initiators = new List<string> { null };

		private string?[] entryInitiators = Array.Empty<string>();

		private string[] entryStripped = Array.Empty<string>();

		private string[] entryStrippedLower = Array.Empty<string>();

		private readonly REPOButton?[] rows = (REPOButton?[])(object)new REPOButton[10];

		private readonly REPOScrollViewElement?[] rowElems = (REPOScrollViewElement?[])(object)new REPOScrollViewElement[10];

		private readonly REPOLabel?[] detailRows = (REPOLabel?[])(object)new REPOLabel[20];

		private readonly REPOScrollViewElement?[] detailRowElems = (REPOScrollViewElement?[])(object)new REPOScrollViewElement[20];

		private REPOLabel? emptyLabel;

		private REPOScrollViewElement? emptyElem;

		private REPOInputField? searchField;

		private REPOScrollViewElement? searchElem;

		private REPOButton? facetBtn;

		private REPOScrollViewElement? facetElem;

		private REPOButton? initiatorBtn;

		private REPOScrollViewElement? initiatorElem;

		private REPOButton? prevBtn;

		private REPOButton? nextBtn;

		private REPOButton? backBtn;

		private REPOButton? copyBtn;

		private REPOButton? steamBtn;

		private REPOLabel? pageLabel;

		private string? detailSteamId;

		private string? detailRaw;

		private bool tabVisible = true;

		private int ViewCount => view.Count;

		private int TotalPages => Math.Max(1, (ViewCount + 10 - 1) / 10);

		internal HistoryPageController(REPOPopupPage page, IReadOnlyList<string> entries)
		{
			this.page = page;
			this.entries = entries;
			BuildInitiatorIndex();
			RebuildView();
		}

		internal void Build()
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Expected O, but got Unknown
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected O, but got Unknown
			page.AddElement((BuilderDelegate)delegate(Transform t)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0125: Unknown result type (might be due to invalid IL or missing references)
				//IL_0170: Unknown result type (might be due to invalid IL or missing references)
				//IL_0175: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
				prevBtn = MenuAPI.CreateREPOButton("< Prev", (Action)Prev, t, BandPos);
				nextBtn = MenuAPI.CreateREPOButton("Next >", (Action)Next, t, BandPos);
				backBtn = MenuAPI.CreateREPOButton("< Back", (Action)ShowList, t, BandPos);
				copyBtn = MenuAPI.CreateREPOButton("Copy", (Action)CopyDetail, t, BandPos);
				steamBtn = MenuAPI.CreateREPOButton("Steam", (Action)OpenSteam, t, BandPos);
				((TMP_Text)steamBtn.labelTMP).richText = true;
				CenterInColumn(prevBtn, 0);
				CenterInColumn(backBtn, 0);
				CenterInColumn(nextBtn, 2);
				CenterInColumn(copyBtn, 2);
				CenterInColumn(steamBtn, 1);
				((TMP_Text)steamBtn.labelTMP).text = "<color=#66c0f4>Steam</color>";
				float num3 = (ModStyle.BandRight - ModStyle.BandLeft) / 5f;
				pageLabel = MenuAPI.CreateREPOLabel("", t, BandPos);
				((TMP_Text)pageLabel.labelTMP).fontSize = 14f;
				((TMP_Text)pageLabel.labelTMP).horizontalAlignment = (HorizontalAlignmentOptions)2;
				RectTransform rectTransform = ((REPOElement)pageLabel).rectTransform;
				Vector2 sizeDelta = ((REPOElement)pageLabel).rectTransform.sizeDelta;
				sizeDelta.x = num3;
				rectTransform.sizeDelta = sizeDelta;
				RectTransform rectTransform2 = ((TMP_Text)pageLabel.labelTMP).rectTransform;
				sizeDelta = ((TMP_Text)pageLabel.labelTMP).rectTransform.sizeDelta;
				sizeDelta.x = num3;
				rectTransform2.sizeDelta = sizeDelta;
				((Transform)((REPOElement)pageLabel).rectTransform).localPosition = new Vector3(ModStyle.ColumnCenter(1, 5) - num3 / 2f, 20f, 0f);
			});
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0015: 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)
				searchField = MenuAPI.CreateREPOInputField("Search", (Action<string>)OnSearchChanged, sv, default(Vector2), false, "name, id, action", "");
				((TMP_Text)searchField.labelTMP).fontSize = 14f;
				return ((REPOElement)searchField).rectTransform;
			}, 0f, 2f);
			searchElem = (((Object)(object)searchField != (Object)null) ? ((Component)searchField).GetComponent<REPOScrollViewElement>() : null);
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: 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)
				facetBtn = MenuAPI.CreateREPOButton(FacetCaption(), (Action)CycleFacet, sv, default(Vector2));
				((TMP_Text)facetBtn.labelTMP).richText = true;
				((TMP_Text)facetBtn.labelTMP).fontSize = 14f;
				facetBtn.overrideButtonSize = new Vector2(250f, 24f);
				return ((REPOElement)facetBtn).rectTransform;
			}, 0f, 2f);
			facetElem = (((Object)(object)facetBtn != (Object)null) ? ((Component)facetBtn).GetComponent<REPOScrollViewElement>() : null);
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: 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)
				initiatorBtn = MenuAPI.CreateREPOButton(InitiatorCaption(), (Action)CycleInitiator, sv, default(Vector2));
				((TMP_Text)initiatorBtn.labelTMP).richText = true;
				((TMP_Text)initiatorBtn.labelTMP).fontSize = 14f;
				initiatorBtn.overrideButtonSize = new Vector2(250f, 24f);
				return ((REPOElement)initiatorBtn).rectTransform;
			}, 0f, 2f);
			initiatorElem = (((Object)(object)initiatorBtn != (Object)null) ? ((Component)initiatorBtn).GetComponent<REPOScrollViewElement>() : null);
			for (int num = 0; num < 10; num++)
			{
				int slot = num;
				page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
				{
					//IL_0038: 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_009f: Unknown result type (might be due to invalid IL or missing references)
					rows[slot] = MenuAPI.CreateREPOButton("", (Action)delegate
					{
						SelectSlot(slot);
					}, sv, default(Vector2));
					((TMP_Text)rows[slot].labelTMP).richText = true;
					((TMP_Text)rows[slot].labelTMP).fontSize = 14f;
					rows[slot].overrideButtonSize = new Vector2(250f, 24f);
					return ((REPOElement)rows[slot]).rectTransform;
				}, 0f, 2f);
				rowElems[num] = (((Object)(object)rows[num] != (Object)null) ? ((Component)rows[num]).GetComponent<REPOScrollViewElement>() : null);
			}
			for (int num2 = 0; num2 < 20; num2++)
			{
				int slot2 = num2;
				page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
				{
					//IL_0019: Unknown result type (might be due to invalid IL or missing references)
					//IL_001f: Unknown result type (might be due to invalid IL or missing references)
					detailRows[slot2] = MenuAPI.CreateREPOLabel("", sv, default(Vector2));
					((TMP_Text)detailRows[slot2].labelTMP).enableWordWrapping = true;
					((TMP_Text)detailRows[slot2].labelTMP).richText = true;
					((TMP_Text)detailRows[slot2].labelTMP).fontSize = 14f;
					return ((REPOElement)detailRows[slot2]).rectTransform;
				}, 0f, 2f);
				detailRowElems[num2] = (((Object)(object)detailRows[num2] != (Object)null) ? ((Component)detailRows[num2]).GetComponent<REPOScrollViewElement>() : null);
			}
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0009: 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)
				emptyLabel = MenuAPI.CreateREPOLabel("No moderation events yet.", sv, default(Vector2));
				((TMP_Text)emptyLabel.labelTMP).fontSize = 14f;
				return ((REPOElement)emptyLabel).rectTransform;
			}, 0f, 0f);
			emptyElem = (((Object)(object)emptyLabel != (Object)null) ? ((Component)emptyLabel).GetComponent<REPOScrollViewElement>() : null);
			ShowList();
		}

		internal void SetTabVisible(bool visible)
		{
			tabVisible = visible;
			if (visible)
			{
				ShowList();
				return;
			}
			for (int i = 0; i < 10; i++)
			{
				if ((Object)(object)rowElems[i] != (Object)null)
				{
					rowElems[i].visibility = false;
				}
			}
			HideDetail();
			if ((Object)(object)emptyElem != (Object)null)
			{
				emptyElem.visibility = false;
			}
			UnfocusSearch();
			if ((Object)(object)searchElem != (Object)null)
			{
				searchElem.visibility = false;
			}
			if ((Object)(object)facetElem != (Object)null)
			{
				facetElem.visibility = false;
			}
			if ((Object)(object)initiatorElem != (Object)null)
			{
				initiatorElem.visibility = false;
			}
			SetActiveSafe((Component?)(object)prevBtn, active: false);
			SetActiveSafe((Component?)(object)nextBtn, active: false);
			SetActiveSafe((Component?)(object)pageLabel, active: false);
			SetActiveSafe((Component?)(object)backBtn, active: false);
			SetActiveSafe((Component?)(object)copyBtn, active: false);
			SetActiveSafe((Component?)(object)steamBtn, active: false);
		}

		private void UnfocusSearch()
		{
			if ((Object)(object)searchField != (Object)null && (Object)(object)searchField.inputStringSystem != (Object)null)
			{
				searchField.inputStringSystem.isFocused = false;
			}
		}

		internal void ShowList()
		{
			if (!tabVisible)
			{
				return;
			}
			for (int i = 0; i < 10; i++)
			{
				int num = pageIndex * 10 + i;
				bool flag = num < ViewCount;
				if ((Object)(object)rowElems[i] != (Object)null)
				{
					rowElems[i].visibility = flag;
				}
				if (flag && (Object)(object)rows[i] != (Object)null)
				{
					((TMP_Text)rows[i].labelTMP).text = RowCaption(EntryAt(num));
				}
			}
			HideDetail();
			detailRaw = null;
			if ((Object)(object)searchElem != (Object)null)
			{
				searchElem.visibility = true;
			}
			if ((Object)(object)facetElem != (Object)null)
			{
				facetElem.visibility = true;
			}
			if ((Object)(object)initiatorElem != (Object)null)
			{
				initiatorElem.visibility = initiators.Count > 1;
			}
			if ((Object)(object)facetBtn != (Object)null)
			{
				((TMP_Text)facetBtn.labelTMP).text = FacetCaption();
			}
			if ((Object)(object)emptyElem != (Object)null)
			{
				emptyElem.visibility = ViewCount == 0;
			}
			if ((Object)(object)emptyLabel != (Object)null && ViewCount == 0)
			{
				((TMP_Text)emptyLabel.labelTMP).text = ((entries.Count == 0) ? "No moderation events yet." : "No matching events.");
			}
			SetActiveSafe((Component?)(object)prevBtn, ViewCount > 0 && pageIndex > 0);
			SetActiveSafe((Component?)(object)nextBtn, ViewCount > 0 && pageIndex < TotalPages - 1);
			SetActiveSafe((Component?)(object)pageLabel, ViewCount > 0);
			SetActiveSafe((Component?)(object)backBtn, active: false);
			SetActiveSafe((Component?)(object)copyBtn, active: false);
			SetActiveSafe((Component?)(object)steamBtn, active: false);
			if ((Object)(object)copyBtn != (Object)null)
			{
				((TMP_Text)copyBtn.labelTMP).text = "Copy";
			}
			if ((Object)(object)pageLabel != (Object)null)
			{
				((TMP_Text)pageLabel.labelTMP).text = $"Page {pageIndex + 1}/{TotalPages}";
			}
			page.scrollView.SetScrollPosition(0f);
		}

		private void SelectSlot(int slot)
		{
			if (!tabVisible)
			{
				return;
			}
			int num = pageIndex * 10 + slot;
			if (num >= ViewCount)
			{
				return;
			}
			string text = (detailRaw = MenuUiHelpers.StripRichText(EntryAt(num)));
			List<string> list = BuildDetailLines(text);
			for (int i = 0; i < 20; i++)
			{
				bool flag = i < list.Count;
				if ((Object)(object)detailRowElems[i] != (Object)null)
				{
					detailRowElems[i].visibility = flag;
				}
				if (flag && (Object)(object)detailRows[i] != (Object)null)
				{
					((TMP_Text)detailRows[i].labelTMP).text = list[i];
					MenuUiHelpers.SizeWrappedLabel(detailRows[i], list[i], 250f);
				}
			}
			for (int j = 0; j < 10; j++)
			{
				if ((Object)(object)rowElems[j] != (Object)null)
				{
					rowElems[j].visibility = false;
				}
			}
			if ((Object)(object)emptyElem != (Object)null)
			{
				emptyElem.visibility = false;
			}
			UnfocusSearch();
			if ((Object)(object)searchElem != (Object)null)
			{
				searchElem.visibility = false;
			}
			if ((Object)(object)facetElem != (Object)null)
			{
				facetElem.visibility = false;
			}
			if ((Object)(object)initiatorElem != (Object)null)
			{
				initiatorElem.visibility = false;
			}
			SetActiveSafe((Component?)(object)prevBtn, active: false);
			SetActiveSafe((Component?)(object)nextBtn, active: false);
			SetActiveSafe((Component?)(object)backBtn, active: true);
			SetActiveSafe((Component?)(object)copyBtn, active: true);
			if ((Object)(object)copyBtn != (Object)null)
			{
				((TMP_Text)copyBtn.labelTMP).text = "Copy";
			}
			SetActiveSafe((Component?)(object)pageLabel, active: false);
			detailSteamId = TargetSteamIdOf(text);
			SetActiveSafe((Component?)(object)steamBtn, SteamUtils.TryParseValidSteamId(detailSteamId, out var _));
			page.scrollView.SetScrollPosition(0f);
		}

		private void HideDetail()
		{
			for (int i = 0; i < 20; i++)
			{
				if ((Object)(object)detailRowElems[i] != (Object)null)
				{
					detailRowElems[i].visibility = false;
				}
			}
		}

		private static List<string> BuildDetailLines(string raw)
		{
			int num = raw.IndexOf("] ", StringComparison.Ordinal);
			string text = ((num >= 0) ? raw.Substring(num + 2) : raw);
			List<string> list = new List<string>();
			list.Add("<size=135%><color=" + SevColor(raw) + ">● " + EventTitle(raw) + "</color></size>");
			List<string> list2 = list;
			string text2 = TimeOf(raw);
			if (text2.Length > 0)
			{
				list2.Add("<size=85%><color=#9aa4ad>" + text2 + "</color></size>");
			}
			List<(string, string)> list3 = ParseFields(text);
			if (list3.Count > 0)
			{
				foreach (var (text3, text4) in list3)
				{
					list2.Add("<size=85%><color=#8a94a0>" + text3 + "</color></size>  <color=#e6eaee>" + text4 + "</color>");
				}
				list2.Add("<size=75%><color=#69737d>" + text + "</color></size>");
			}
			else
			{
				list2.Add("<color=#cdd2d8>" + text + "</color>");
			}
			return list2;
		}

		private void CopyDetail()
		{
			if (!string.IsNullOrEmpty(detailRaw))
			{
				GUIUtility.systemCopyBuffer = detailRaw;
				if ((Object)(object)copyBtn != (Object)null)
				{
					((TMP_Text)copyBtn.labelTMP).text = "Copied";
				}
			}
		}

		private void OpenSteam()
		{
			SteamUtils.OpenProfile(detailSteamId);
		}

		private static string? TargetSteamIdOf(string strippedEntry)
		{
			int num = strippedEntry.IndexOf("] ", StringComparison.Ordinal);
			string body = ((num >= 0) ? strippedEntry.Substring(num + 2) : strippedEntry);
			foreach (var (text, result) in CoreFieldsOf(body))
			{
				if (text == "Steam ID")
				{
					return result;
				}
			}
			return null;
		}

		private void Prev()
		{
			if (pageIndex > 0)
			{
				pageIndex--;
				ShowList();
			}
		}

		private void Next()
		{
			if (pageIndex < TotalPages - 1)
			{
				pageIndex++;
				ShowList();
			}
		}

		private string EntryAt(int global)
		{
			return entries[view[view.Count - 1 - global]];
		}

		private void OnSearchChanged(string value)
		{
			string text = (value ?? "").Trim().ToLowerInvariant();
			if (!(text == searchText))
			{
				searchText = text;
				pageIndex = 0;
				RebuildView();
				ShowList();
			}
		}

		private void CycleFacet()
		{
			facetIndex = (facetIndex + 1) % FacetLabels.Length;
			if ((Object)(object)facetBtn != (Object)null)
			{
				((TMP_Text)facetBtn.labelTMP).text = FacetCaption();
			}
			pageIndex = 0;
			RebuildView();
			ShowList();
		}

		private string FacetCaption()
		{
			string text = FacetLabels[facetIndex];
			string arg = ((facetIndex == 0) ? text : ("<color=" + FacetColor(facetIndex) + ">" + text + "</color>"));
			return string.Format("Filter: {0}  <color={1}>({2})</color>", arg, "#6f7d88", ViewCount);
		}

		private static string FacetColor(int idx)
		{
			return idx switch
			{
				1 => "#ef5350", 
				2 => "#ff7043", 
				3 => "#b57ae0", 
				4 => "#66bb6a", 
				5 => "#8aa0b0", 
				_ => "#66b2ff", 
			};
		}

		private void CycleInitiator()
		{
			initiatorIndex = (initiatorIndex + 1) % initiators.Count;
			if ((Object)(object)initiatorBtn != (Object)null)
			{
				((TMP_Text)initiatorBtn.labelTMP).text = InitiatorCaption();
			}
			pageIndex = 0;
			RebuildView();
			ShowList();
		}

		private string InitiatorCaption()
		{
			if (initiatorIndex == 0)
			{
				return "By: All";
			}
			string text = initiators[initiatorIndex] ?? "All";
			int num = text.IndexOf(" (", StringComparison.Ordinal);
			string text2 = ((num > 0) ? text.Substring(0, num) : text);
			if (text2.Length > 18)
			{
				text2 = MenuUiHelpers.TruncateSafe(text2, 17) + "…";
			}
			return "By: <color=#66b2ff>" + text2 + "</color>";
		}

		private void RebuildView()
		{
			view.Clear();
			for (int i = 0; i < entries.Count; i++)
			{
				if ((facetIndex == 0 || FacetMatches(entryStripped[i])) && (initiatorIndex == 0 || string.Equals(entryInitiators[i], initiators[initiatorIndex], StringComparison.Ordinal)) && (searchText.Length <= 0 || entryStrippedLower[i].IndexOf(searchText, StringComparison.Ordinal) >= 0))
				{
					view.Add(i);
				}
			}
		}

		private void BuildInitiatorIndex()
		{
			entryInitiators = new string[entries.Count];
			entryStripped = new string[entries.Count];
			entryStrippedLower = new string[entries.Count];
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			for (int i = 0; i < entries.Count; i++)
			{
				string text = MenuUiHelpers.StripRichText(entries[i]);
				entryStripped[i] = text;
				entryStrippedLower[i] = text.ToLowerInvariant();
				string text2 = InitiatorOf(text);
				entryInitiators[i] = text2;
				if (text2 != null && hashSet.Add(text2))
				{
					initiators.Add(text2);
				}
			}
		}

		private static string? InitiatorOf(string strippedEntry)
		{
			int num = strippedEntry.IndexOf("] ", StringComparison.Ordinal);
			string body = ((num >= 0) ? strippedEntry.Substring(num + 2) : strippedEntry);
			foreach (var (text, result) in CoreFieldsOf(body))
			{
				if (text == "By")
				{
					return result;
				}
			}
			return null;
		}

		private bool FacetMatches(string strippedEntry)
		{
			string text = HistoryPatterns.EventKind(strippedEntry).ToLowerInvariant();
			return facetIndex switch
			{
				1 => text.StartsWith("kick request", StringComparison.Ordinal) || text.StartsWith("ban request", StringComparison.Ordinal) || text.StartsWith("banning", StringComparison.Ordinal) || text.StartsWith("player kicked", StringComparison.Ordinal) || text.StartsWith("player banned", StringComparison.Ordinal) || text.StartsWith("ghost player", StringComparison.Ordinal), 
				2 => text.StartsWith("rpc flood", StringComparison.Ordinal), 
				3 => text.StartsWith("global voice", StringComparison.Ordinal), 
				4 => text.StartsWith("moderator ", StringComparison.Ordinal), 
				5 => !text.StartsWith("kick request", StringComparison.Ordinal) && !text.StartsWith("ban request", StringComparison.Ordinal) && !text.StartsWith("banning", StringComparison.Ordinal) && !text.StartsWith("player kicked", StringComparison.Ordinal) && !text.StartsWith("player banned", StringComparison.Ordinal) && !text.StartsWith("ghost player", StringComparison.Ordinal) && !text.StartsWith("rpc flood", StringComparison.Ordinal) && !text.StartsWith("global voice", StringComparison.Ordinal) && !text.StartsWith("moderator ", StringComparison.Ordinal), 
				_ => true, 
			};
		}

		private static string RowCaption(string entry)
		{
			string text = MenuUiHelpers.StripRichText(entry);
			int num = text.IndexOf("] ", StringComparison.Ordinal);
			string text2 = ((num >= 0) ? text.Substring(0, num + 1) : "");
			string body = ((num >= 0) ? text.Substring(num + 2) : text);
			string text3 = EventTitle(text);
			string text4 = CaptionSuffix(body);
			if (!string.IsNullOrEmpty(text4))
			{
				text3 = text3 + " - " + text4;
			}
			if (text3.Length > 34)
			{
				text3 = MenuUiHelpers.TruncateSafe(text3, 33) + "…";
			}
			string text5 = ((text2.Length > 0) ? ("<color=#9aa4ad>" + text2 + "</color> ") : "");
			return "<color=" + SevColor(text) + ">●</color> " + text5 + text3;
		}

		private static string? CaptionSuffix(string body)
		{
			foreach (var (text, text2) in ParseFields(body))
			{
				switch (text)
				{
				case "Player":
					return text2;
				case "By":
				case "Cancelled by":
				{
					int num = text2.IndexOf(" (", StringComparison.Ordinal);
					return "by " + ((num > 0) ? text2.Substring(0, num) : text2);
				}
				case "Duration":
				case "Reason":
					return text2;
				}
			}
			return null;
		}

		private static string SevColor(string strippedEntry)
		{
			string text = HistoryPatterns.EventKind(strippedEntry).ToLowerInvariant();
			if (text.StartsWith("announcement", StringComparison.Ordinal))
			{
				return "#4dd0e1";
			}
			if (text.StartsWith("rpc flood", StringComparison.Ordinal))
			{
				return "#ff7043";
			}
			if (text.StartsWith("global voice", StringComparison.Ordinal))
			{
				return "#b57ae0";
			}
			if (text.StartsWith("moderator granted", StringComparison.Ordinal))
			{
				return "#66bb6a";
			}
			if (text.StartsWith("moderator revoked", StringComparison.Ordinal))
			{
				return "#ffa726";
			}
			if (text.StartsWith("moderator token revoked", StringComparison.Ordinal))
			{
				return "#ffa726";
			}
			if (text.StartsWith("banning", StringComparison.Ordinal) || text.StartsWith("ban request", StringComparison.Ordinal) || text.StartsWith("player banned", StringComparison.Ordinal) || text.StartsWith("ghost player banned", StringComparison.Ordinal))
			{
				return "#ef5350";
			}
			if (text.StartsWith("kick request", StringComparison.Ordinal) || text.StartsWith("player kicked", StringComparison.Ordinal) || text.StartsWith("ghost player kicked", StringComparison.Ordinal))
			{
				return "#ff7043";
			}
			if (text.StartsWith("run start countdown", StringComparison.Ordinal))
			{
				return "#8aa0b0";
			}
			if (text.StartsWith("private voice channel", StringComparison.Ordinal))
			{
				return "#8aa0b0";
			}
			if (text.Contains("ban"))
			{
				return "#ef5350";
			}
			if (text.Contains("kick"))
			{
				return "#ff7043";
			}
			return "#8aa0b0";
		}

		private static string EventTitle(string strippedEntry)
		{
			string text = HistoryPatterns.EventKind(strippedEntry).ToLowerInvariant();
			if (text.StartsWith("announcement", StringComparison.Ordinal))
			{
				return "Announcement";
			}
			if (text.StartsWith("rpc flood", StringComparison.Ordinal))
			{
				return "RPC Flood";
			}
			if (text.StartsWith("global voice unmute", StringComparison.Ordinal))
			{
				return "Voice Unmute";
			}
			if (text.StartsWith("global voice mute", StringComparison.Ordinal))
			{
				return "Voice Mute";
			}
			if (text.StartsWith("moderator granted", StringComparison.Ordinal))
			{
				return "Mod Granted";
			}
			if (text.StartsWith("moderator revoked", StringComparison.Ordinal))
			{
				return "Mod Revoked";
			}
			if (text.StartsWith("moderator token revoked", StringComparison.Ordinal))
			{
				return "Token Revoked";
			}
			if (text.StartsWith("ghost player banned", StringComparison.Ordinal))
			{
				return "Ghost Banned";
			}
			if (text.StartsWith("ghost player kicked", StringComparison.Ordinal))
			{
				return "Ghost Kicked";
			}
			if (text.StartsWith("ban request", StringComparison.Ordinal) || text.StartsWith("banning", StringComparison.Ordinal))
			{
				return "Ban Request";
			}
			if (text.StartsWith("kick request", StringComparison.Ordinal))
			{
				return "Kick Request";
			}
			if (text.StartsWith("player banned", StringComparison.Ordinal))
			{
				return "Player Banned";
			}
			if (text.StartsWith("player kicked", StringComparison.Ordinal))
			{
				return "Player Kicked";
			}
			if (text.StartsWith("run start countdown begun", StringComparison.Ordinal))
			{
				return "Countdown Started";
			}
			if (text.StartsWith("run start countdown cancelled", StringComparison.Ordinal))
			{
				return "Countdown Cancelled";
			}
			if (text.StartsWith("run started", StringComparison.Ordinal))
			{
				return "Run Started";
			}
			if (text.StartsWith("start game", StringComparison.Ordinal))
			{
				return "Start Game";
			}
			if (text.StartsWith("admin menu", StringComparison.Ordinal))
			{
				return "Admin Menu";
			}
			if (text.StartsWith("return to lobby", StringComparison.Ordinal))
			{
				return "Back to Lobby";
			}
			if (text.StartsWith("private voice channel opened", StringComparison.Ordinal))
			{
				return "Private Voice On";
			}
			if (text.StartsWith("private voice channel closed", StringComparison.Ordinal))
			{
				return "Private Voice Off";
			}
			if (text.StartsWith("private voice channel key rotated", StringComparison.Ordinal))
			{
				return "Private Voice Key";
			}
			return HistoryPatterns.EventKind(strippedEntry);
		}

		private static string TimeOf(string strippedEntry)
		{
			int num = strippedEntry.IndexOf(']');
			if (num <= 1)
			{
				return "";
			}
			return strippedEntry.Substring(1, num - 1);
		}

		private static List<(string Label, string Value)> ParseFields(string body)
		{
			List<(string, string)> list = new List<(string, string)>();
			Match match = HistoryPatterns.MetaTailPattern.Match(body);
			if (match.Success)
			{
				string[] array = match.Groups["meta"].Value.Split('|');
				foreach (string text in array)
				{
					string text2 = text.Trim();
					if (text2.Length != 0)
					{
						int num = text2.IndexOf(':');
						if (num > 0)
						{
							list.Add((text2.Substring(0, num).Trim(), text2.Substring(num + 1).Trim()));
						}
						else
						{
							list.Add(("Info", text2));
						}
					}
				}
				body = body.Substring(0, match.Index);
			}
			List<(string, string)> list2 = ParseCoreFields(body);
			list2.AddRange(list);
			return list2;
		}

		private static List<(string Label, string Value)> CoreFieldsOf(string body)
		{
			Match match = HistoryPatterns.MetaTailPattern.Match(body);
			if (match.Success)
			{
				body = body.Substring(0, match.Index);
			}
			return ParseCoreFields(body);
		}

		private static List<(string Label, string Value)> ParseCoreFields(string body)
		{
			List<(string, string)> list = new List<(string, string)>();
			Match match = HistoryPatterns.FloodPattern.Match(body);
			if (match.Success)
			{
				list.Add(("Player", match.Groups["name"].Value.Trim()));
				list.Add(("Actor #", match.Groups["actor"].Value));
				list.Add(("Steam ID", match.Groups["sid"].Value));
				if (match.Groups["reason"].Value.Length > 0)
				{
					list.Add(("Reason", match.Groups["reason"].Value));
				}
				list.Add(("Action", "Auto-kick"));
				return list;
			}
			match = HistoryPatterns.GhostPatternStrict.Match(body);
			if (!match.Success)
			{
				match = HistoryPatterns.GhostPattern.Match(body);
			}
			if (match.Success)
			{
				list.Add(("Player", match.Groups["name"].Value.Trim()));
				list.Add(("Actor #", match.Groups["actor"].Value));
				if (match.Groups["sid"].Success)
				{
					list.Add(("Steam ID", match.Groups["sid"].Value));
				}
				AddActionField(list, match.Groups["verb"].Value);
				AddByField(list, body);
				return list;
			}
			Regex[][] targetPatternTiers = HistoryPatterns.TargetPatternTiers;
			foreach (Regex[] array in targetPatternTiers)
			{
				Regex[] array2 = array;
				foreach (Regex regex in array2)
				{
					match = regex.Match(body);
					if (match.Success)
					{
						list.Add(("Player", match.Groups["name"].Value.Trim()));
						list.Add(("Steam ID", match.Groups["sid"].Value));
						AddActionField(list, match.Groups["verb"].Value);
						AddByField(list, body);
						return list;
					}
				}
			}
			match = HistoryPatterns.CountdownBegunPattern.Match(body);
			if (match.Success)
			{
				list.Add(("Duration", match.Groups["dur"].Value));
				return list;
			}
			match = HistoryPatterns.CountdownCancelPattern.Match(body);
			if (match.Success)
			{
				if (match.Groups["who"].Success)
				{
					string value = match.Groups["who"].Value;
					if (value.Equals("host", StringComparison.OrdinalIgnoreCase))
					{
						list.Add(("By", "Host"));
					}
					else
					{
						list.Add(("Cancelled by", value));
					}
				}
				else
				{
					string value2 = match.Groups["reason"].Value;
					list.Add(("Reason", char.ToUpperInvariant(value2[0]) + value2.Substring(1)));
				}
				return list;
			}
			AddByField(list, body);
			return list;
		}

		private static void AddActionField(List<(string, string)> fields, string verb)
		{
			string text;
			switch (verb.ToLowerInvariant())
			{
			case "kick":
			case "kicked":
				text = "Kick";
				break;
			case "banned":
			case "ban":
			case "banning":
				text = "Ban";
				break;
			case "granted to":
				text = "Grant";
				break;
			case "revoked from":
				text = "Revoke";
				break;
			case "mute":
				text = "Mute";
				break;
			case "unmute":
				text = "Unmute";
				break;
			default:
				text = null;
				break;
			}
			string text2 = text;
			if (text2 != null)
			{
				fields.Add(("Action", text2));
			}
		}

		private static void AddByField(List<(string, string)> fields, string body)
		{
			Match match = HistoryPatterns.ByPattern.Match(body);
			if (match.Success)
			{
				fields.Add(("By", match.Groups["name"].Value + " (" + match.Groups["sid"].Value + ")"));
			}
			else if (body.EndsWith("by host", StringComparison.OrdinalIgnoreCase))
			{
				fields.Add(("By", "Host"));
			}
		}

		private static void CenterInColumn(REPOButton? btn, int col)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)btn == (Object)null))
			{
				Vector2 labelSize = btn.GetLabelSize();
				((Transform)((REPOElement)btn).rectTransform).localPosition = new Vector3(ModStyle.ColumnCenter(col, 5) - labelSize.x / 2f, 20f, 0f);
			}
		}

		private static void SetActiveSafe(Component? c, bool active)
		{
			if ((Object)(object)c != (Object)null)
			{
				c.gameObject.SetActive(active);
			}
		}
	}
	internal static class HistoryPatterns
	{
		internal static readonly Regex[] StrictTargetPatterns = new Regex[4]
		{
			new Regex("^(?<verb>Kick|Ban|Banning) request\\s+(?<name>.*)\\s*\\((?<sid>[^()]+?)\\)\\s*(?=from player:)", RegexOptions.Compiled),
			new Regex("^Player (?<verb>kicked|banned):\\s*(?<name>.*)\\s*\\((?<sid>[^()]+?)\\)\\s*(?=by host\\s*$)", RegexOptions.Compiled),
			new Regex("^Moderator (?<verb>granted to|revoked from)\\s+(?<name>.*)\\s*\\((?<sid>[^()]+?)\\)\\s*(?=by host\\s*$)", RegexOptions.Compiled),
			new Regex("^Global voice (?<verb>mute|unmute):\\s*(?<name>.*)\\s*\\((?<sid>[^()]+?)\\)\\s*(?=by\\b)", RegexOptions.Compiled)
		};

		internal static readonly Regex[] TargetPatterns = new Regex[4]
		{
			new Regex("^(?<verb>Kick|Ban|Banning) request\\s+(?<name>.*?)\\s*\\((?<sid>[^()]+?)\\)", RegexOptions.Compiled),
			new Regex("^Player (?<verb>kicked|banned):\\s*(?<name>.*?)\\s*\\((?<sid>[^()]+?)\\)", RegexOptions.Compiled),
			new Regex("^Moderator (?<verb>granted to|revoked from)\\s+(?<name>.*?)\\s*\\((?<sid>[^()]+?)\\)", RegexOptions.Compiled),
			new Regex("^Global voice (?<verb>mute|unmute):\\s*(?<name>.*?)\\s*\\((?<sid>[^()]+?)\\)", RegexOptions.Compiled)
		};

		internal static readonly Regex[][] TargetPatternTiers = new Regex[2][] { StrictTargetPatterns, TargetPatterns };

		internal static readonly Regex FloodPattern = new Regex("^RPC flood:\\s*(?<name>.*)\\s*\\(actor\\s*(?<actor>-?\\d+),\\s*SteamID:\\s*(?<sid>[^()]+?)\\)\\s*(?<reason>.*?)\\s*-\\s*auto-kicked$", RegexOptions.Compiled);

		internal static readonly Regex GhostPatternStrict = new Regex("^Ghost player (?<verb>kicked|banned)\\s*\\(ActorNumber:\\s*(?<actor>-?\\d+),\\s*Name:\\s*(?<name>.*?)(?:,\\s*SteamID:\\s*(?<sid>[^()]+?))?\\)\\s*(?:by host|by:\\s*.*\\([^()]*\\))\\s*$", RegexOptions.Compiled);

		internal static readonly Regex GhostPattern = new Regex("^Ghost player (?<verb>kicked|banned)\\s*\\(ActorNumber:\\s*(?<actor>-?\\d+),\\s*Name:\\s*(?<name>.*?)(?:,\\s*SteamID:\\s*(?<sid>[^()]+?))?\\)", RegexOptions.Compiled);

		internal static readonly Regex CountdownBegunPattern = new Regex("^Run start countdown begun \\((?<dur>[^()]+)\\)$", RegexOptions.Compiled);

		internal static readonly Regex CountdownCancelPattern = new Regex("^Run start countdown cancelled(?: by (?<who>.+)| \\((?<reason>[^()]+)\\))$", RegexOptions.Compiled);

		internal static readonly Regex ByPattern = new Regex("^.*(?:\\bby:?\\s*|\\bfrom player:\\s*)(?<name>.*?)\\s*\\((?<sid>[^()]+)\\)\\s*$", RegexOptions.Compiled);

		internal static readonly Regex MetaTailPattern = new Regex("\\s*\\[(?<meta>[^\\[\\]]*)\\]\\s*$", RegexOptions.Compiled);

		private static readonly char[] KindCutChars = new char[2] { ':', '(' };

		internal static string EventKind(string strippedEntry)
		{
			int num = strippedEntry.IndexOf("] ", StringComparison.Ordinal);
			string text = ((num >= 0) ? strippedEntry.Substring(num + 2) : strippedEntry);
			int num2 = text.IndexOfAny(KindCutChars);
			return ((num2 >= 0) ? text.Substring(0, num2) : text).Trim();
		}
	}
	internal enum HudCorner
	{
		TopLeft,
		TopRight,
		BottomLeft,
		BottomRight
	}
	internal readonly struct HudPlacement
	{
		internal readonly float AnchorX;

		internal readonly float AnchorY;

		internal readonly float PivotX;

		internal readonly float PivotY;

		internal readonly float InsetX;

		internal readonly float InsetY;

		internal readonly float GrowSign;

		internal HudPlacement(float ax, float ay, float px, float py, float ix, float iy, float grow)
		{
			AnchorX = ax;
			AnchorY = ay;
			PivotX = px;
			PivotY = py;
			InsetX = ix;
			InsetY = iy;
			GrowSign = grow;
		}
	}
	internal static class HudLayout
	{
		internal const float Inset = 40f;

		internal static HudPlacement For(HudCorner corner)
		{
			return corner switch
			{
				HudCorner.TopLeft => new HudPlacement(0f, 1f, 0f, 1f, 40f, -40f, -1f), 
				HudCorner.BottomLeft => new HudPlacement(0f, 0f, 0f, 0f, 40f, 40f, 1f), 
				HudCorner.BottomRight => new HudPlacement(1f, 0f, 1f, 0f, -40f, 40f, 1f), 
				_ => new HudPlacement(1f, 1f, 1f, 1f, -40f, -40f, -1f), 
			};
		}
	}
	internal static class MarkerMeshes
	{
		internal static Mesh Bipyramid(int sides, float radius, float topHeight, float bottomHeight)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			sides = Mathf.Max(3, sides);
			List<Vector3> verts = new List<Vector3>(sides * 6);
			List<int> tris = new List<int>(sides * 6);
			Vector3 a = default(Vector3);
			((Vector3)(ref a))..ctor(0f, topHeight, 0f);
			Vector3 a2 = default(Vector3);
			((Vector3)(ref a2))..ctor(0f, 0f - bottomHeight, 0f);
			for (int i = 0; i < sides; i++)
			{
				Vector3 val = Ring(i, sides, radius);
				Vector3 val2 = Ring(i + 1, sides, radius);
				AddTri(verts, tris, a, val2, val);
				AddTri(verts, tris, a2, val, val2);
			}
			return Build(verts, tris);
		}

		internal static Mesh Pyramid(float radius, float height, int sides)
		{
			//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_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_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)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			sides = Mathf.Max(3, sides);
			List<Vector3> verts = new List<Vector3>(sides * 6);
			List<int> tris = new List<int>(sides * 6);
			Vector3 a = default(Vector3);
			((Vector3)(ref a))..ctor(0f, height, 0f);
			for (int i = 0; i < sides; i++)
			{
				Vector3 val = Ring(i, sides, radius);
				Vector3 val2 = Ring(i + 1, sides, radius);
				AddTri(verts, tris, a, val2, val);
				AddTri(verts, tris, Vector3.zero, val, val2);
			}
			return Build(verts, tris);
		}

		internal static Mesh GemCut(int sides, float girdleRadius, float tableRadius, float crownHeight, float pavilionDepth)
		{
			//IL_0059: 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)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: 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_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			sides = Mathf.Max(3, sides);
			List<Vector3> verts = new List<Vector3>(sides * 12);
			List<int> tris = new List<int>(sides * 12);
			Vector3 a = default(Vector3);
			((Vector3)(ref a))..ctor(0f, crownHeight, 0f);
			Vector3 a2 = default(Vector3);
			((Vector3)(ref a2))..ctor(0f, 0f - pavilionDepth, 0f);
			for (int i = 0; i < sides; i++)
			{
				Vector3 val = Ring(i, sides, girdleRadius);
				Vector3 val2 = Ring(i + 1, sides, girdleRadius);
				Vector3 val3 = Ring(i, sides, tableRadius, 0.5f, crownHeight);
				Vector3 val4 = Ring(i + 1, sides, tableRadius, 0.5f, crownHeight);
				AddTri(verts, tris, a, val4, val3);
				AddTri(verts, tris, val3, val2, val);
				AddTri(verts, tris, val2, val3, val4);
				AddTri(verts, tris, a2, val, val2);
			}
			return Build(verts, tris);
		}

		internal static Mesh Band(int sides, float outerRadius, float innerRadius, float height)
		{
			//IL_0035: 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_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_0058: 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_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//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_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_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: 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)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			sides = Mathf.Max(3, sides);
			float num = height * 0.5f;
			List<Vector3> verts = new List<Vector3>(sides * 24);
			List<int> tris = new List<int>(sides * 24);
			for (int i = 0; i < sides; i++)
			{
				Vector3 val = Ring(i, sides, outerRadius, 0f, num);
				Vector3 val2 = Ring(i + 1, sides, outerRadius, 0f, num);
				Vector3 val3 = Ring(i, sides, outerRadius, 0f, 0f - num);
				Vector3 val4 = Ring(i + 1, sides, outerRadius, 0f, 0f - num);
				Vector3 a = Ring(i, sides, innerRadius, 0f, num);
				Vector3 val5 = Ring(i + 1, sides, innerRadius, 0f, num);
				Vector3 val6 = Ring(i, sides, innerRadius, 0f, 0f - num);
				Vector3 val7 = Ring(i + 1, sides, innerRadius, 0f, 0f - num);
				AddTri(verts, tris, val, val2, val4);
				AddTri(verts, tris, val, val4, val3);
				AddTri(verts, tris, a, val7, val5);
				AddTri(verts, tris, a, val6, val7);
				AddTri(verts, tris, a, val2, val);
				AddTri(verts, tris, a, val5, val2);
				AddTri(verts, tris, val6, val3, val4);
				AddTri(verts, tris, val6, val4, val7);
			}
			return Build(verts, tris);
		}

		private static Vector3 Ring(int i, int sides, float radius, float halfStepOffset = 0f, float y = 0f)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			float num = ((float)i + halfStepOffset) / (float)sides * MathF.PI * 2f;
			return new Vector3(Mathf.Cos(num) * radius, y, Mathf.Sin(num) * radius);
		}

		private static void AddTri(List<Vector3> verts, List<int> tris, Vector3 a, Vector3 b, Vector3 c)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			int count = verts.Count;
			verts.Add(a);
			verts.Add(b);
			verts.Add(c);
			tris.Add(count);
			tris.Add(count + 1);
			tris.Add(count + 2);
		}

		private static Mesh Build(List<Vector3> verts, List<int> tris)
		{
			//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_0011: Expected O, but got Unknown
			Mesh val = new Mesh
			{
				name = "SharePermissions_MarkerMesh"
			};
			val.SetVertices(verts);
			val.SetTriangles(tris, 0);
			val.RecalculateNormals();
			val.RecalculateBounds();
			return val;
		}
	}
	internal sealed class MembersPanelController
	{
		private const int MaxRows = 20;

		private readonly REPOPopupPage page;

		private readonly REPOButton?[] rows = (REPOButton?[])(object)new REPOButton[20];

		private readonly REPOScrollViewElement?[] rowElems = (REPOScrollViewElement?[])(object)new REPOScrollViewElement[20];

		private readonly int[] rowActors = new int[20];

		private readonly string[] rowCaptionBase = new string[20];

		private readonly bool[] rowTalking = new bool[20];

		private readonly float[] rowTalkHoldUntil = new float[20];

		private readonly HashSet<int> actorsWithAvatars = new HashSet<int>();

		private REPOLabel? footer;

		private REPOScrollViewElement? footerElem;

		private string noteDraft = "";

		private bool suspended;

		private bool tabVisible = true;

		private static readonly Color ConfirmHeaderColor = ModStyle.ConfirmDanger;

		internal MembersPanelController(REPOPopupPage page)
		{
			this.page = page;
			for (int i = 0; i < 20; i++)
			{
				rowActors[i] = -1;
			}
		}

		internal void Build()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Expected O, but got Unknown
			for (int i = 0; i < 20; i++)
			{
				int slot = i;
				page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
				{
					//IL_0038: 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_009f: Unknown result type (might be due to invalid IL or missing references)
					rows[slot] = MenuAPI.CreateREPOButton("", (Action)delegate
					{
						OnRowClick(slot);
					}, sv, default(Vector2));
					((TMP_Text)rows[slot].labelTMP).richText = true;
					((TMP_Text)rows[slot].labelTMP).fontSize = 14f;
					rows[slot].overrideButtonSize = new Vector2(250f, 24f);
					return ((REPOElement)rows[slot]).rectTransform;
				}, 0f, 2f);
				rowElems[i] = (((Object)(object)rows[i] != (Object)null) ? ((Component)rows[i]).GetComponent<REPOScrollViewElement>() : null);
			}
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_002a: 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)
				string text = (SemiFunc.IsMasterClient() ? "Click a player to manage" : "Click a player for notes - the host manages roles");
				string text2 = "<color=#6f7d88>" + text + "</color>";
				footer = MenuAPI.CreateREPOLabel(text2, sv, default(Vector2));
				((TMP_Text)footer.labelTMP).richText = true;
				((TMP_Text)footer.labelTMP).fontSize = 14f;
				MenuUiHelpers.SizeWrappedLabel(footer, text2, 250f);
				return ((REPOElement)footer).rectTransform;
			}, 4f, 0f);
			footerElem = (((Object)(object)footer != (Object)null) ? ((Component)footer).GetComponent<REPOScrollViewElement>() : null);
			Refresh();
		}

		internal void SetTabVisible(bool visible)
		{
			tabVisible = visible;
			if (visible)
			{
				Refresh();
				return;
			}
			for (int i = 0; i < 20; i++)
			{
				if ((Object)(object)rowElems[i] != (Object)null)
				{
					rowElems[i].visibility = false;
				}
			}
			if ((Object)(object)footerElem != (Object)null)
			{
				footerElem.visibility = false;
			}
		}

		internal void Refresh()
		{
			if ((Object)(object)page == (Object)null || suspended || !tabVisible)
			{
				return;
			}
			Player[] array = PhotonNetwork.PlayerList ?? Array.Empty<Player>();
			array = Array.FindAll(array, (Player p) => p.IsLocal || MenuUiHelpers.HasVisibleGlyph(p.NickName));
			if (array.Length > 20)
			{
				Plugin.Logger.LogWarning((object)$"Members panel: {array.Length} players exceeds {20} rows; showing first {20}");
			}
			BuildAvatarActorSet();
			for (int num = 0; num < 20; num++)
			{
				bool flag = num < array.Length;
				if ((Object)(object)rowElems[num] != (Object)null)
				{
					rowElems[num].visibility = flag;
				}
				if (!flag)
				{
					rowActors[num] = -1;
					rowCaptionBase[num] = "";
					rowTalking[num] = false;
					rowTalkHoldUntil[num] = 0f;
					continue;
				}
				Player val = array[num];
				if (rowActors[num] != val.ActorNumber)
				{
					rowTalking[num] = false;
					rowTalkHoldUntil[num] = 0f;
				}
				rowActors[num] = val.ActorNumber;
				rowCaptionBase[num] = CaptionBase(val, !val.IsLocal && !actorsWithAvatars.Contains(val.ActorNumber));
				ApplyCaption(num);
			}
			if ((Object)(object)footerElem != (Object)null)
			{
				footerElem.visibility = true;
			}
		}

		internal void TickTalking()
		{
			if ((Object)(object)page == (Object)null || suspended || !tabVisible)
			{
				return;
			}
			if (!ModConfig.ShowTalkDots.Value)
			{
				for (int i = 0; i < 20; i++)
				{
					if (rowTalking[i])
					{
						rowTalking[i] = false;
						rowTalkHoldUntil[i] = 0f;
						ApplyCaption(i);
					}
				}
				return;
			}
			float unscaledTime = Time.unscaledTime;
			Player localPlayer = PhotonNetwork.LocalPlayer;
			int num = ((localPlayer != null) ? localPlayer.ActorNumber : (-1));
			bool localActive = PrivateVoiceChannel.LocalActive;
			for (int j = 0; j < 20; j++)
			{
				int num2 = rowActors[j];
				if (num2 >= 0 && num2 != num)
				{
					float num3 = ((localActive && PrivateVoiceChannel.IsMemberActor(num2)) ? PrivateSpeakers.AmplitudeFor(num2) : VoiceChatPatch.AmplitudeFor(num2));
					if (num3 > 0.005f)
					{
						rowTalkHoldUntil[j] = unscaledTime + 0.18f;
					}
					bool flag = unscaledTime < rowTalkHoldUntil[j];
					if (flag != rowTalking[j])
					{
						rowTalking[j] = flag;
						ApplyCaption(j);
					}
				}
			}
		}

		private void ApplyCaption(int r)
		{
			if (!((Object)(object)rows[r] == (Object)null))
			{
				((TMP_Text)rows[r].labelTMP).text = (rowTalking[r] ? (rowCaptionBase[r] + "  <color=#d9e8a8>●</color>") : rowCaptionBase[r]);
			}
		}

		private void OnRowClick(int slot)
		{
			if (slot < 0 || slot >= 20)
			{
				return;
			}
			int num = rowActors[slot];
			if (num < 0)
			{
				return;
			}
			Room currentRoom = PhotonNetwork.CurrentRoom;
			Player val = ((currentRoom != null) ? currentRoom.GetPlayer(num, false) : null);
			if (val == null)
			{
				return;
			}
			if (val.IsLocal)
			{
				if (ModerationActions.LocalCanModerate)
				{
					OpenNotesOnly(val);
				}
			}
			else if (SemiFunc.IsMasterClient())
			{
				OpenActions(val);
			}
			else if (ModerationActions.LocalCanModerate)
			{
				OpenNotesOnly(val);
			}
		}

		private void OpenActions(Player player)
		{
			if (MenuUiHelpers.IsOpenPending)
			{
				return;
			}
			ModRole modRole = RoleResolver.ResolveByPlayer(player);
			if (modRole == ModRole.Host)
			{
				return;
			}
			string name = MenuUiHelpers.SanitizePlayerName(player.NickName, $"Player_{player.ActorNumber}");
			string steamId = PlayerRegistry.Instance.Resolve(player.ActorNumber) ?? "";
			int actor = player.ActorNumber;
			suspended = true;
			REPOPopupPage sub = MenuUiHelpers.CreatePage("Manage Member", Unsuspend);
			string text = (string.IsNullOrEmpty(steamId) ? "" : ("  <color=#6f7d88>" + steamId + "</color>"));
			MenuUiHelpers.AddLabel(sub, "<size=115%>" + name + "</size>\n<size=75%><color=" + ModStyle.RoleHex(modRole) + ">● " + ModStyle.RoleLabel(modRole) + "</color>" + text + "</size>");
			if (modRole == ModRole.Moderator)
			{
				MenuUiHelpers.AddScrollViewButton(sub, "Demote moderator", delegate
				{
					CloseSub();
					Confirm("Demote", "Remove moderator access from " + name + "?", delegate
					{
						ModerationActions.DemoteModerator(actor, steamId);
					});
				});
			}
			else if (modRole == ModRole.ModUser && !string.IsNullOrEmpty(steamId))
			{
				MenuUiHelpers.AddScrollViewButton(sub, "Promote to moderator", delegate
				{
					CloseSub();
					Confirm("Promote", "Grant moderator access to " + name + "?", delegate
					{
						ModerationActions.PromoteModerator(actor, steamId);
					});
				});
			}
			else
			{
				MenuUiHelpers.AddLabel(sub, "<size=75%><color=#6f7d88>Promote requires the mod installed</color></size>");
			}
			if (!string.IsNullOrEmpty(steamId))
			{
				BuildNameColorActions(sub, CloseSub, name, steamId, modRole);
			}
			BuildNotesSection(sub, CloseSub, name, steamId);
			MenuUiHelpers.OpenPage(sub);
			void CloseSub()
			{
				MenuUiHelpers.ClosePage(sub);
				Unsuspend();
			}
			void Unsuspend()
			{
				suspended = false;
				Refresh();
			}
		}

		private void OpenNotesOnly(Player player)
		{
			REPOPopupPage sub;
			if (!MenuUiHelpers.IsOpenPending)
			{
				string text = MenuUiHelpers.SanitizePlayerName(player.NickName, $"Player_{player.ActorNumber}");
				string text2 = PlayerRegistry.Instance.Resolve(player.ActorNumber) ?? "";
				suspended = true;
				sub = MenuUiHelpers.CreatePage("Player Notes", Unsuspend);
				string text3 = (string.IsNullOrEmpty(text2) ? "" : ("\n<size=75%><color=#6f7d88>" + text2 + "</color></size>"));
				MenuUiHelpers.AddLabel(sub, "<size=115%>" + text + "</size>" + text3);
				BuildNotesSection(sub, CloseSub, text, text2);
				MenuUiHelpers.OpenPage(sub);
			}
			void CloseSub()
			{
				MenuUiHelpers.ClosePage(sub);
				Unsuspend();
			}
			void Unsuspend()
			{
				suspended = false;
				Refresh();
			}
		}

		private void BuildNameColorActions(REPOPopupPage sub, Action closeSub, string name, string steamId, ModRole role)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			Color seed = (Color)(((??)NameColors.Resolve(steamId, role)) ?? Color.white);
			MenuUiHelpers.AddScrollViewButton(sub, "Set name color", delegate
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				closeSub();
				ColorPickerPage.Open(name + "'s name color", "Color for " + name + " only. Overrides the host and moderator colors for them.", seed, delegate(Color picked)
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					NameColors.SetOverride(steamId, picked);
					NameColorSync.Broadcast();
				}, NameColors.GetOverride(steamId).HasValue ? "Clear name color" : null, NameColors.GetOverride(steamId).HasValue ? ((Action)delegate
				{
					NameColors.SetOverride(steamId, null);
					NameColorSync.Broadcast();
				}) : null);
			});
		}

		private void BuildNotesSection(REPOPopupPage sub, Action closeSub, string playerName, string steamId)
		{
			//IL_021f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Expected O, but got Unknown
			noteDraft = "";
			if (string.IsNullOrEmpty(steamId))
			{
				MenuUiHelpers.AddLabel(sub, "<size=75%><color=#6f7d88>Notes need a resolved Steam ID</color></size>");
				return;
			}
			List<PlayerNote> list = NotesStore.For(steamId);
			MenuUiHelpers.AddLabel(sub, $"<size=115%>Notes ({list.Count})</size>");
			string text = ModerationActions.LocalSteamId ?? "";
			bool flag = SemiFunc.IsMasterClient();
			foreach (PlayerNote item in list)
			{
				PlayerNote note = item;
				string text2 = DateTimeOffset.FromUnixTimeSeconds(note.CreatedUnix).ToLocalTime().ToString("yyyy-MM-dd");
				string text3 = ((note.AuthorName.Length > 0) ? note.AuthorName : "unknown");
				string text4 = ((note.LobbyName.Length > 0 && !PlayerNotesCore.LooksLikeRoomGuid(note.LobbyName)) ? (", " + note.LobbyName) : "");
				string caption = note.Text + "\n<size=75%><color=#9aa4ad>" + text3 + text4 + ", " + text2 + "</color></size>";
				if (flag || (note.AuthorSteamId.Length > 0 && note.AuthorSteamId == text))
				{
					MenuUiHelpers.AddScrollViewButton(sub, "", delegate
					{
						closeSub();
						Confirm("Delete note", "Delete this note about " + playerName + "?", delegate
						{
							NotesStore.Delete(note.Id);
							if (SemiFunc.IsMasterClient())
							{
								NotesSync.BroadcastTombstone(note.Id);
							}
							else
							{
								CommandSender.Send("NoteDelete", new object[1] { note.Id }, (ReceiverGroup)2);
							}
						});
					}, delegate(REPOButton b)
					{
						((TMP_Text)b.labelTMP).richText = true;
						((TMP_Text)b.labelTMP).fontSize = 14f;
						((TMP_Text)b.labelTMP).text = caption;
						MenuUiHelpers.SizeWrappedButton(b, caption, 250f);
					});
				}
				else
				{
					MenuUiHelpers.AddLabel(sub, caption);
				}
			}
			sub.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				REPOInputField val = MenuAPI.CreateREPOInputField("Note", (Action<string>)delegate(string v)
				{
					noteDraft = v ?? "";
				}, sv, default(Vector2), false, "add a note", "");
				((TMP_Text)val.labelTMP).fontSize = 14f;
				return ((REPOElement)val).rectTransform;
			}, 4f, 0f);
			MenuUiHelpers.AddScrollViewButton(sub, "Add note", delegate
			{
				//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
				Room currentRoom = PhotonNetwork.CurrentRoom;
				string text5 = PlayerNotesCore.SanitizeName((currentRoom != null) ? currentRoom.Name : null, 40);
				if (text5.Length == 0 || PlayerNotesCore.LooksLikeRoomGuid(text5))
				{
					Player masterClient = PhotonNetwork.MasterClient;
					text5 = PlayerNotesCore.SanitizeName((masterClient != null) ? masterClient.NickName : null, 40);
				}
				Player localPlayer = PhotonNetwork.LocalPlayer;
				string authorName = MenuUiHelpers.SanitizePlayerName((localPlayer != null) ? localPlayer.NickName : null, "unknown");
				if (NotesStore.TryAddLocal(steamId, noteDraft, ModerationActions.LocalSteamId ?? "0", authorName, text5, out PlayerNote note2, out string reason))
				{
					if (SemiFunc.IsMasterClient())
					{
						NotesSync.ForwardNew(new List<PlayerNote> { note2 }, new List<string>(), -1);
					}
					else
					{
						NotesSync.SendOneToHost(note2);
					}
				}
				else if (reason == "target-full")
				{
					NotificationCenter.EnqueueDirect($"Note not added - {playerName} already has {20} notes", ModStyle.SevInfo);
				}
				noteDraft = "";
				closeSub();
			});
		}

		private void BuildAvatarActorSet()
		{
			actorsWithAvatars.Clear();
			foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
			{
				if (!((Object)(object)item == (Object)null))
				{
					PhotonView component = ((Component)item).GetComponent<PhotonView>();
					if ((Object)(object)component != (Object)null && component.Owner != null)
					{
						actorsWithAvatars.Add(component.Owner.ActorNumber);
					}
				}
			}
		}

		private static void Confirm(string verb, string message, Action onConfirm)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			MenuUiHelpers.ShowTwoOptionPopup(verb, ConfirmHeaderColor, message, onConfirm, null);
		}

		private static string CaptionBase(Player player, bool connecting)
		{
			ModRole role = RoleResolver.ResolveByPlayer(player);
			string text = ModStyle.RoleHex(role);
			string text2 = MenuUiHelpers.SanitizePlayerName(player.NickName, $"Player_{player.ActorNumber}");
			if (text2.Length > 16)
			{
				text2 = text2.Substring(0, 15) + "…";
			}
			if (player.IsLocal)
			{
				text2 += " <color=#9aa4ad>(you)</color>";
			}
			string text3 = PlayerRegistry.Instance.Resolve(player.ActorNumber);
			int num = ((!string.IsNullOrEmpty(text3)) ? NotesStore.CountFor(text3) : 0);
			if (num > 0)
			{
				text2 += string.Format(" <size={0}><color={1}>({2})</color></size>", "75%", "#9aa4ad", num);
			}
			string text4 = (connecting ? "<color=#6f7d88>connecting</color>" : ("<color=" + text + ">" + ModStyle.RoleLabel(role) + "</color>"));
			return "<color=" + text + ">●</color> " + text2 + "  <size=75%>" + text4 + "</size>";
		}
	}
	internal sealed class MembersRefresher : MonoBehaviour
	{
		internal Action? OnRefresh;

		internal Action? OnTick;

		private int lastCount = -1;

		private int lastAvatarCount = -1;

		private void OnEnable()
		{
			Moderators.Instance.Changed += Trigger;
			ModUsers.Instance.Changed += Trigger;
		}

		private void OnDisable()
		{
			Moderators.Instance.Changed -= Trigger;
			ModUsers.Instance.Changed -= Trigger;
		}

		private void Update()
		{
			Room currentRoom = PhotonNetwork.CurrentRoom;
			int num = ((currentRoom != null) ? currentRoom.PlayerCount : 0);
			int num2 = SemiFunc.PlayerGetAll()?.Count ?? 0;
			if (num != lastCount || num2 != lastAvatarCount)
			{
				lastCount = num;
				lastAvatarCount = num2;
				Trigger();
			}
			OnTick?.Invoke();
		}

		private void Trigger()
		{
			OnRefresh?.Invoke();
		}
	}
	internal static class MenuUiHelpers
	{
		private static MenuButtonPopUp? menuButtonPopup;

		internal const int MaxPlayerNameLength = 32;

		private static int nextFakePageIndex = -2000;

		private static float openBlockedUntil;

		internal static bool IsOpenPending => Time.unscaledTime < openBlockedUntil;

		internal static string StripRichText(string? text)
		{
			if (string.IsNullOrEmpty(text))
			{
				return "";
			}
			string source = Regex.Replace(text, "<[^>]*>", string.Empty);
			return new string(source.Where((char c) => !char.IsControl(c)).ToArray());
		}

		internal static string SanitizePlayerName(string? name, string? fallback = "Unknown")
		{
			if (string.IsNullOrWhiteSpace(name))
			{
				return fallback ?? "";
			}
			string text = StripRichText(name).Trim();
			if (string.IsNullOrWhiteSpace(text))
			{
				return fallback ?? "";
			}
			if (text.Length > 32)
			{
				text = TruncateSafe(text, 32) + "...";
			}
			return text;
		}

		internal static string TruncateSafe(string text, int max)
		{
			if (text.Length <= max)
			{
				return text;
			}
			int num = max;
			if (num > 0 && char.IsHighSurrogate(text[num - 1]))
			{
				num--;
			}
			return text.Substring(0, num);
		}

		internal static bool HasVisibleGlyph(string? name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return false;
			}
			for (int i = 0; i < name.Length; i++)
			{
				char c = name[i];
				int cp;
				if (char.IsHighSurrogate(c) && i + 1 < name.Length && char.IsLowSurrogate(name[i + 1]))
				{
					cp = char.ConvertToUtf32(c, name[++i]);
				}
				else
				{
					if (char.IsSurrogate(c))
					{
						continue;
					}
					cp = c;
				}
				if (IsVisibleCodePoint(cp))
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsKnownInvisibleCodePoint(int cp)
		{
			switch (cp)
			{
			case 4447:
			case 4448:
			case 6158:
			case 10240:
			case 12644:
			case 65440:
				return true;
			default:
				return false;
			}
		}

		private static bool IsVisibleCodePoint(int cp)
		{
			if (IsKnownInvisibleCodePoint(cp))
			{
				return false;
			}
			UnicodeCategory unicodeCategory = CharUnicodeInfo.GetUnicodeCategory(cp);
			if ((uint)(unicodeCategory - 5) <= 2u || (uint)(unicodeCategory - 11) <= 6u || unicodeCategory == UnicodeCategory.OtherNotAssigned)
			{
				return false;
			}
			return true;
		}

		internal static REPOPopupPage CreatePage(string title, Action onClose)
		{
			//IL_0044: 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_0070: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			REPOPopupPage page = MenuAPI.CreateREPOPopupPage(title, (PresetSide)0, false, true, 4f);
			AlignPopupToContentColumn(page);
			page.menuPage.menuPageIndex = (MenuPageIndex)(nextFakePageIndex--);
			MenuModalGatePatch.RegisterModalPage(page.menuPage);
			page.onEscapePressed = (ShouldCloseMenuDelegate)delegate
			{
				bool flag = (Object)(object)MenuManager.instance != (Object)null && (Object)(object)MenuManager.instance.currentMenuPage == (Object)(object)page.menuPage;
				if (flag)
				{
					onClose();
				}
				return flag;
			};
			page.AddElement((BuilderDelegate)delegate(Transform transform)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				REPOButton val = MenuAPI.CreateREPOButton("Close", (Action)delegate
				{
					ClosePage(page, onClose);
				}, transform, new Vector2(ModStyle.BandLeft, 20f));
				((Transform)((REPOElement)val).rectTransform).localPosition = new Vector3(ModStyle.ColumnCenter(4, 5) - val.GetLabelSize().x / 2f, 20f, 0f);
			});
			return page;
		}

		private static void AlignPopupToContentColumn(REPOPopupPage page)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: 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_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				page.maskRectTransform.GetWorldCorners(array);
				float x = ((Component)page).transform.InverseTransformPoint(array[0]).x;
				float x2 = ((Component)page).transform.InverseTransformPoint(array[3]).x;
				if (x2 - x < 50f)
				{
					return;
				}
				ModStyle.BandLeft = x;
				ModStyle.BandRight = x2;
				TextMeshProUGUI headerTMP = page.headerTMP;
				if (!((Object)(object)headerTMP == (Object)null))
				{
					((TMP_Text)headerTMP).ForceMeshUpdate(false, false);
					Bounds textBounds = ((TMP_Text)headerTMP).textBounds;
					Vector3 val;
					if (!(((Bounds)(ref textBounds)).extents.x > 0f))
					{
						RectTransform rectTransform = ((TMP_Text)headerTMP).rectTransform;
						Rect rect = ((TMP_Text)headerTMP).rectTransform.rect;
						val = ((Transform)rectTransform).TransformPoint(Vector2.op_Implicit(((Rect)(ref rect)).center));
					}
					else
					{
						val = ((TMP_Text)headerTMP).transform.TransformPoint(((Bounds)(ref textBounds)).center);
					}
					Vector3 val2 = val;
					float x3 = ((Component)page).transform.InverseTransformPoint(val2).x;
					float num = (x + x2) / 2f + 0f;
					Vector3 localPosition = ((Transform)((TMP_Text)headerTMP).rectTransform).localPosition;
					localPosition.x += num - x3;
					((Transform)((TMP_Text)headerTMP).rectTransform).localPosition = localPosition;
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[SharePermissions] Popup column alignment failed (using fallbacks): " + ex.Message));
			}
		}

		internal static float LayoutScrollMask(REPOPopupPage page, float topBand)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_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_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				page.maskRectTransform.GetWorldCorners(array);
				float y = ((Component)page).transform.InverseTransformPoint(array[1]).y;
				float y2 = ((Component)page).transform.InverseTransformPoint(array[0]).y;
				float num = page.maskPadding.bottom + (56f - y2);
				page.maskPadding = new Padding(0f, topBand, 0f, Mathf.Max(0f, num));
				return y;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[SharePermissions] Mask layout failed, using fallback: " + ex.Message));
				page.maskPadding = new Padding(0f, topBand, 0f, 30f);
				return 300f;
			}
		}

		internal static void OpenPage(REPOPopupPage page)
		{
			openBlockedUntil = Time.unscaledTime + 0.1f;
			((MonoBehaviour)MenuManager.instance).StartCoroutine(OpenPageDelayed(page));
		}

		private static IEnumerator OpenPageDelayed(REPOPopupPage page)
		{
			yield return (object)new WaitForSeconds(0.05f);
			if ((Object)(object)page != (Object)null && (Object)(object)page.menuPage != (Object)null)
			{
				page.OpenPage(false);
			}
		}

		internal static void ClosePage(REPOPopupPage page, Action? onClose = null)
		{
			onClose?.Invoke();
			if (!((Object)(object)page == (Object)null))
			{
				page.ClosePage(true);
				MenuManager.instance.PageRemove(page.menuPage);
			}
		}

		internal static void AddLabel(REPOPopupPage parent, string text)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			parent.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
			{
				//IL_0009: 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)
				REPOLabel val = MenuAPI.CreateREPOLabel(text, scrollView, default(Vector2));
				((TMP_Text)val.labelTMP).richText = true;
				((TMP_Text)val.labelTMP).fontSize = 14f;
				SizeWrappedLabel(val, text, 250f);
				return ((REPOElement)val).rectTransform;
			}, 0f, 6f);
		}

		internal static void SizeWrappedLabel(REPOLabel label, string text, float width)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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)
			TextMeshProUGUI labelTMP = label.labelTMP;
			((TMP_Text)labelTMP).enableWordWrapping = true;
			((TMP_Text)labelTMP).ForceMeshUpdate(false, false);
			float y = ((TMP_Text)labelTMP).GetPreferredValues(text, width, 0f).y;
			((REPOElement)label).rectTransform.sizeDelta = new Vector2(width, y);
			((TMP_Text)labelTMP).rectTransform.sizeDelta = new Vector2(width, y);
		}

		internal static void SizeWrappedButton(REPOButton button, string text, float width)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_001c: 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_0024: 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_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI labelTMP = button.labelTMP;
			RectTransform rectTransform = ((TMP_Text)labelTMP).rectTransform;
			Vector3 localPosition = ((Transform)rectTransform).localPosition;
			Vector2 anchorMin = (rectTransform.anchorMax = Vector2.zero);
			rectTransform.anchorMin = anchorMin;
			rectTransform.pivot = Vector2.zero;
			((Transform)rectTransform).localPosition = localPosition;
			((TMP_Text)labelTMP).enableAutoSizing = false;
			((TMP_Text)labelTMP).enableWordWrapping = true;
			((TMP_Text)labelTMP).overflowMode = (TextOverflowModes)0;
			((TMP_Text)labelTMP).margin = Vector4.zero;
			((TMP_Text)labelTMP).alignment = (TextAlignmentOptions)1025;
			float num = width - Mathf.Max(0f, localPosition.x);
			((TMP_Text)labelTMP).ForceMeshUpdate(false, false);
			float y = ((TMP_Text)labelTMP).GetPreferredValues(text, num, 0f).y;
			rectTransform.sizeDelta = new Vector2(num, y);
			button.overrideButtonSize = new Vector2(width, y + Mathf.Max(0f, localPosition.y));
		}

		internal static void AddScrollViewButton(REPOPopupPage parent, string text, Action onClick, Action<REPOButton>? configure = null)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			parent.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform scrollView)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0032: 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)
				REPOButton val = MenuAPI.CreateREPOButton(text, onClick, scrollView, default(Vector2));
				if (text.Length > 24)
				{
					Vector2 labelSize = val.GetLabelSize();
					labelSize.x = 250f;
					val.overrideButtonSize = labelSize;
					REPOTextScroller val2 = ((Component)val.labelTMP).gameObject.AddComponent<REPOTextScroller>();
					val2.maxCharacters = 24;
				}
				configure?.Invoke(val);
				return ((REPOElement)val).rectTransform;
			}, 0f, 0f);
		}

		internal static void ShowTwoOptionPopup(string title, Color headerColor, string message, Action? onLeftClicked, Action? onRightClicked, string leftTitle = "Yes", string rightTitle = "No")
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)menuButtonPopup))
			{
				menuButtonPopup = ((Component)MenuManager.instance).gameObject.AddComponent<MenuButtonPopUp>();
			}
			menuButtonPopup.option1Event = new UnityEvent();
			menuButtonPopup.option2Event = new UnityEvent();
			if (onLeftClicked != null)
			{
				menuButtonPopup.option1Event.AddListener(new UnityAction(onLeftClicked.Invoke));
			}
			if (onRightClicked != null)
			{
				menuButtonPopup.option2Event.AddListener(new UnityAction(onRightClicked.Invoke));
			}
			MenuManager.instance.PagePopUpTwoOptions(menuButtonPopup, title, (LocalizedAsset)null, headerColor, message, (LocalizedAsset)null, leftTitle, (LocalizedAsset)null, rightTitle, (LocalizedAsset)null, true);
		}
	}
	internal static class ModerationActions
	{
		internal readonly struct GhostInfo
		{
			internal readonly Player Player;

			internal readonly PlayerAvatar? UntrustedAvatar;

			internal GhostInfo(Player player, PlayerAvatar? untrustedAvatar)
			{
				Player = player;
				UntrustedAvatar = untrustedAvatar;
			}
		}

		private static readonly Color ConfirmHeaderColor = ModStyle.ConfirmDanger;

		private static string cachedLocalSteamId = "";

		private const float AnnounceCooldownSeconds = 3f;

		private static float lastAnnounceSentAt;

		internal static string LocalSteamId
		{
			get
			{
				if ((Object)(object)PlayerAvatar.instance != (Object)null)
				{
					string value = SemiFunc.PlayerGetSteamID(PlayerAvatar.instance);
					if (!string.IsNullOrEmpty(value))
					{
						cachedLocalSteamId = value;
					}
				}
				return cachedLocalSteamId;
			}
		}

		private static bool LocalIsHost => SemiFunc.IsMasterClient();

		private static bool LocalIsModerator => Moderators.Instance.IsModerator(LocalSteamId);

		internal static bool LocalCanModerate
		{
			get
			{
				if (!LocalIsHost)
				{
					return LocalIsModerator;
				}
				return true;
			}
		}

		internal static bool PersistentBanAvailable
		{
			get
			{
				if (LocalCanModerate)
				{
					if (!LocalIsHost)
					{
						return HostCapabilities.PersistentBan;
					}
					return BanEnforcerBridge.IsAvailable;
				}
				return false;
			}
		}

		internal static void ClearSessionCache()
		{
			cachedLocalSteamId = "";
		}

		internal static IEnumerable<GhostInfo> GetGhosts()
		{
			HashSet<int> actorsWithAvatars = new HashSet<int>();
			Dictionary<int, PlayerAvatar> byActor = new Dictionary<int, PlayerAvatar>();
			PlayerAvatar[] array = Object.FindObjectsOfType<PlayerAvatar>();
			foreach (PlayerAvatar val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					continue;
				}
				PhotonView component = ((Component)val).GetComponent<PhotonView>();
				if (!((Object)(object)component == (Object)null) && component.Owner != null)
				{
					int actorNumber = component.Owner.ActorNumber;
					byActor[actorNumber] = val;
					if (PlayerValidator.Validate(val).IsValid)
					{
						actorsWithAvatars.Add(actorNumber);
					}
				}
			}
			Player[] playerList = PhotonNetwork.PlayerList;
			foreach (Player val2 in playerList)
			{
				if (!val2.IsLocal && !actorsWithAvatars.Contains(val2.ActorNumber) && MenuUiHelpers.HasVisibleGlyph(val2.NickName))
				{
					byActor.TryGetValue(val2.ActorNumber, out PlayerAvatar value);
					yield return new GhostInfo(val2, value);
				}
			}
		}

		internal static bool ShouldShowKickFor(PlayerAvatar target)
		{
			if ((Object)(object)target == (Object)null || target.isLocal)
			{
				return false;
			}
			if (!LocalCanModerate)
			{
				return false;
			}
			PhotonView component = ((Component)target).GetComponent<PhotonView>();
			if (component != null)
			{
				Player owner = component.Owner;
				if (((owner != null) ? new bool?(owner.IsMasterClient) : ((bool?)null)) == true)
				{
					return false;
				}
			}
			if (Moderators.Instance.IsModerator(target) && !LocalIsHost)
			{
				return false;
			}
			return true;
		}

		internal static bool ShouldShowKickForActor(Player target)
		{
			if (target == null || target.IsLocal)
			{
				return false;
			}
			if (!LocalCanModerate)
			{
				return false;
			}
			if (target.IsMasterClient)
			{
				return false;
			}
			string steamId = PlayerRegistry.Instance.Resolve(target.ActorNumber) ?? "";
			if (Moderators.Instance.IsModerator(steamId) && !LocalIsHost)
			{
				return false;
			}
			return true;
		}

		internal static void HandlePlayerKick(PlayerAvatar target)
		{
			if (!ShouldShowKickFor(target))
			{
				return;
			}
			string name = MenuUiHelpers.SanitizePlayerName(SemiFunc.PlayerGetName(target));
			string steamId = SemiFunc.PlayerGetSteamID(target);
			PhotonView component = ((Component)target).GetComponent<PhotonView>();
			int? obj;
			if (component == null)
			{
				obj = null;
			}
			else
			{
				Player owner = component.Owner;
				obj = ((owner != null) ? new int?(owner.ActorNumber) : ((int?)null));
			}
			int actor = obj ?? (-1);
			bool flag = Moderators.Instance.IsModerator(steamId);
			Action kick = delegate
			{
				DispatchPlayer(actor, steamId, ban: false);
			};
			Action ban = delegate
			{
				DispatchPlayer(actor, steamId, ban: true);
			};
			Action pban = (PersistentBanAvailable ? ((Action)delegate
			{
				DispatchPlayer(actor, steamId, ban: true, persistent: true);
			}) : null);
			if (flag)
			{
				ShowKickBanModal(name, delegate
				{
					Confirm(name, "Kick", kick);
				}, delegate
				{
					Confirm(name, "Ban", ban);
				}, (pban == null) ? null : ((Action)delegate
				{
					Confirm(name, "Ban (persistent)", pban);
				}));
			}
			else
			{
				ShowKickBanModal(name, kick, ban, pban);
			}
		}

		private static void DispatchPlayer(int actor, string steamId, bool ban, bool persistent = false)
		{
			if (LocalIsHost)
			{
				if (actor > 0)
				{
					string targetName = SteamName(steamId);
					bool targetIsModerator = Moderators.Instance.IsModerator(steamId);
					PBanOutcome pban = (persistent ? GameActions.RecordPersistentBan(steamId, targetName, null, null) : PBanOutcome.None);
					GameActions.KickByActorNumber(actor, ban);
					AuditEvents.PlayerKickBan(ban, targetName, steamId, actor, targetIsModerator, pban);
				}
			}
			else
			{
				CommandSender.Send("KickPlayer", new object[2]
				{
					steamId,
					persistent ? "pban" : (ban ? "ban" : "kick")
				}, (ReceiverGroup)2);
			}
		}

		internal static void HandleGhostKick(Player ghost)
		{
			if (ShouldShowKickForActor(ghost))
			{
				string targetName = MenuUiHelpers.SanitizePlayerName(ghost.NickName, $"Unknown_{ghost.ActorNumber}");
				ShowKickBanModal(targetName, delegate
				{
					DispatchGhost(ghost, ban: false);
				}, delegate
				{
					DispatchGhost(ghost, ban: true);
				}, PersistentBanAvailable ? ((Action)delegate
				{
					DispatchGhost(ghost, ban: true, persistent: true);
				}) : null);
			}
		}

		private static void DispatchGhost(Player ghost, bool ban, bool persistent = false)
		{
			if (LocalIsHost)
			{
				string text = PlayerRegistry.Instance.TryGetSteamId(ghost.ActorNumber) ?? ghost.UserId;
				string targetName = MenuUiHelpers.SanitizePlayerName(ghost.NickName, $"Unknown_{ghost.ActorNumber}");
				PBanOutcome pban = (persistent ? GameActions.RecordPersistentBan(text, targetName, null, null) : PBanOutcome.None);
				GameActions.KickByActorNumber(ghost.ActorNumber, ban);
				AuditEvents.GhostKickBan(ban, ghost.ActorNumber, ghost.NickName, text, null, null, pban);
			}
			else
			{
				string text2 = $"{ghost.ActorNumber}";
				CommandSender.Send("KickGhostPlayer", new object[2]
				{
					text2,
					persistent ? "pban" : (ban ? "ban" : "kick")
				}, (ReceiverGroup)2);
			}
		}

		internal static void KickPlayer(PlayerAvatar target, bool ban, bool persistent = false)
		{
			if (ShouldShowKickFor(target))
			{
				string steamId = SemiFunc.PlayerGetSteamID(target);
				PhotonView component = ((Component)target).GetComponent<PhotonView>();
				int? obj;
				if (component == null)
				{
					obj = null;
				}
				else
				{
					Player owner = component.Owner;
					obj = ((owner != null) ? new int?(owner.ActorNumber) : ((int?)null));
				}
				int actor = obj ?? (-1);
				DispatchPlayer(actor, steamId, ban, persistent);
			}
		}

		internal static void KickGhost(Player ghost, bool ban, bool persistent = false)
		{
			if (ShouldShowKickForActor(ghost))
			{
				DispatchGhost(ghost, ban, persistent);
			}
		}

		internal static void PromoteModerator(int actor, string? steamId)
		{
			if (!LocalIsHost || string.IsNullOrEmpty(steamId) || actor <= 0)
			{
				return;
			}
			if (!ModUsers.Instance.Contains(steamId) && !Moderators.Instance.IsModerator(steamId))
			{
				Plugin.Logger.LogWarning((object)("Promote refused: " + steamId + " is not running the mod"));
				return;
			}
			bool flag = false;
			foreach (IssuedToken item in from t in PromotedTokenStore.Entries()
				where t.SteamId == steamId
				select t)
			{
				foreach (int item2 in AuthorizedActors.ActorsHolding(item.Token))
				{
					string text = PlayerRegistry.Instance.Resolve(item2);
					if (!string.IsNullOrEmpty(text) && !(text == steamId))
					{
						Moderators.Instance.RemoveModerator(text);
						ModeratorSync.BroadcastRemoval(text);
						AuditEvents.ModeratorRevoked(SteamName(text), text);
						flag = true;
					}
				}
				PromotedTokenStore.Remove(item.Token);
				AuthorizedActors.RevokeToken(item.Token);
			}
			string text2 = TokenGenerator.NewToken();
			PromotedTokenStore.Add(text2, steamId, SteamName(steamId));
			AuthorizedActors.Authorize(actor, text2);
			CommandSender.SendToActors("GrantToken", new object[1] { text2 }, new int[1] { actor });
			bool flag2 = Moderators.Instance.IsModerator(steamId);
			Moderators.Instance.AddModerator(steamId);
			ModeratorSync.BroadcastFullModeratorList();
			if (!flag2)
			{
				AuditSync.SendBacklogTo(actor);
				NotesSync.SendFullTo(actor);
			}
			AuditEvents.ModeratorGranted(SteamName(steamId), steamId);
			if (flag)
			{
				PrivateVoiceSync.Rotate("credential reuse");
			}
			else
			{
				PrivateVoiceSync.Resync();
			}
		}

		internal static void DemoteModerator(int actor, string? steamId)
		{
			if (LocalIsHost && !string.IsNullOrEmpty(steamId) && !(steamId == LocalSteamId))
			{
				string text = AuthorizedActors.TokenFor(actor);
				IssuedToken? label = (string.IsNullOrEmpty(text) ? ((IssuedToken?)null) : PromotedTokenStore.Find(text));
				HashSet<string> hashSet = new HashSet<string> { steamId };
				CollectTokenHolders(text, hashSet);
				if (!string.IsNullOrEmpty(text))
				{
					PromotedTokenStore.Remove(text);
					AuthorizedActors.RevokeToken(text);
				}
				AuthorizedActors.RemoveActor(actor);
				RevokeAllCredentialsFor(hashSet);
				DemoteAndAudit(hashSet, label);
			}
		}

		private static void CollectTokenHolders(string? token, HashSet<string> into)
		{
			if (string.IsNullOrEmpty(token))
			{
				return;
			}
			foreach (int item in AuthorizedActors.ActorsHolding(token))
			{
				string text = PlayerRegistry.Instance.Resolve(item);
				if (!string.IsNullOrEmpty(text))
				{
					into.Add(text);
				}
			}
		}

		private static void DemoteAndAudit(HashSet<string> steamIds, IssuedToken? label)
		{
			foreach (string steamId in steamIds)
			{
				Moderators.Instance.RemoveModerator(steamId);
				ModeratorSync.BroadcastRemoval(steamId);
				string name = ((label.HasValue && steamId == label.Value.SteamId && label.Value.Name.Length > 0) ? label.Value.Name : SteamName(steamId));
				AuditEvents.ModeratorRevoked(name, steamId);
			}
			PrivateVoiceSync.Rotate("demotion");
		}

		private static void RevokeAllCredentialsFor(HashSet<string> steamIds)
		{
			foreach (IssuedToken item in PromotedTokenStore.Entries())
			{
				if (item.SteamId.Length != 0 && steamIds.Contains(item.SteamId))
				{
					CollectTokenHolders(item.Token, steamIds);
					PromotedTokenStore.Remove(item.Token);
					AuthorizedActors.RevokeToken(item.Token);
				}
			}
			Room currentRoom = PhotonNetwork.CurrentRoom;
			if (currentRoom == null)
			{
				return;
			}
			foreach (Player value in currentRoom.Players.Values)
			{
				if (value != null && AuthorizedActors.Contains(value.ActorNumber))
				{
					string text = PlayerRegistry.Instance.Resolve(value.ActorNumber);
					if (!string.IsNullOrEmpty(text) && steamIds.Contains(text))
					{
						string token = AuthorizedActors.TokenFor(value.ActorNumber);
						CollectTokenHolders(token, steamIds);
						PromotedTokenStore.Remove(token);
						AuthorizedActors.RevokeToken(token);
						AuthorizedActors.RemoveActor(value.ActorNumber);
					}
				}
			}
		}

		internal static void RevokeIssuedToken(string token)
		{
			if (!LocalIsHost)
			{
				return;
			}
			IssuedToken? label = PromotedTokenStore.Find(token);
			if (label.HasValue)
			{
				HashSet<string> hashSet = new HashSet<string>();
				if (label.Value.SteamId.Length > 0)
				{
					hashSet.Add(label.Value.SteamId);
				}
				CollectTokenHolders(token, hashSet);
				PromotedTokenStore.Remove(token);
				AuthorizedActors.RevokeToken(token);
				RevokeAllCredentialsFor(hashSet);
				DemoteAndAudit(hashSet, label);
				if (hashSet.Count == 0)
				{
					AuditEvents.TokenRevoked(TokenPrefix(token));
				}
			}
		}

		private static string TokenPrefix(string token)
		{
			return ((token.Length > 12) ? token.Substring(0, 12) : token) + "…";
		}

		private static string SteamName(string? steamId)
		{
			PlayerAvatar val = (string.IsNullOrEmpty(steamId) ? null : SemiFunc.PlayerGetFromSteamID(steamId));
			string text;
			if (!((Object)(object)val != (Object)null))
			{
				text = steamId;
				if (text == null)
				{
					return "";
				}
			}
			else
			{
				text = MenuUiHelpers.SanitizePlayerName(SemiFunc.PlayerGetName(val));
			}
			return text;
		}

		internal static void StartGame()
		{
			if (LocalIsHost)
			{
				StartCountdown.BeginHostAuthoritative(ModConfig.StartCountdownSeconds.Value);
			}
			else
			{
				CommandSender.Send("StartGame", Array.Empty<object>(), (ReceiverGroup)2);
			}
		}

		internal static void TogglePrivateVoice()
		{
			if (SemiFunc.IsMasterClient())
			{
				if (PrivateVoiceChannel.Active)
				{
					PrivateVoiceSync.Close();
				}
				else
				{
					PrivateVoiceSync.Open();
				}
			}
		}

		internal static void BackToLobby()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (!ModConfig.ConfirmBackToLobby.Value)
			{
				DoBackToLobby();
			}
			else
			{
				MenuUiHelpers.ShowTwoOptionPopup("Back to lobby", ConfirmHeaderColor, "Return everyone to the lobby?", DoBackToLobby, null);
			}
		}

		private static void DoBackToLobby()
		{
			if (LocalIsHost)
			{
				GameActions.ReturnToLobby();
			}
			else
			{
				CommandSender.Send("BackToLobby", Array.Empty<object>(), (ReceiverGroup)2);
			}
		}

		internal static bool SendAnnouncement(string? raw)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			if (!LocalIsHost)
			{
				return false;
			}
			string text = AnnounceText.Sanitize(raw);
			if (text.Length == 0)
			{
				return false;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (lastAnnounceSentAt > 0f && realtimeSinceStartup - lastAnnounceSentAt < 3f)
			{
				return false;
			}
			lastAnnounceSentAt = realtimeSinceStartup;
			CommandSender.Send("Announce", new object[1] { text }, (ReceiverGroup)0);
			NotificationCenter.EnqueueDirect("Announcement: " + text, ModStyle.SevAnnounce);
			AuditEvents.Announcement(text);
			return true;
		}

		private static void ShowKickBanModal(string targetName, Action onKick, Action onBan, Action? onPersistentBan = null)
		{
			REPOPopupPage popup = MenuUiHelpers.CreatePage("Player Actions", delegate
			{
			});
			MenuUiHelpers.AddLabel(popup, "Player: " + targetName);
			MenuUiHelpers.AddScrollViewButton(popup, "Kick", delegate
			{
				MenuUiHelpers.ClosePage(popup);
				onKick();
			});
			MenuUiHelpers.AddScrollViewButton(popup, "Ban", delegate
			{
				MenuUiHelpers.ClosePage(popup);
				onBan();
			});
			if (onPersistentBan != null)
			{
				MenuUiHelpers.AddScrollViewButton(popup, "Ban (persistent)", delegate
				{
					MenuUiHelpers.ClosePage(popup);
					onPersistentBan();
				});
			}
			MenuUiHelpers.OpenPage(popup);
		}

		private static void Confirm(string name, string verb, Action onConfirm)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			MenuUiHelpers.ShowTwoOptionPopup("Moderator", ConfirmHeaderColor, name + " is a moderator.\n" + verb + " anyway?", onConfirm, null);
		}
	}
	internal static class ModPanel
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Action <>9__0_0;

			public static BuilderDelegate <>9__0_4;

			internal void <Open>b__0_0()
			{
			}

			internal void <Open>b__0_4(Transform t)
			{
				//IL_002b: 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_004a: 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)
				REPOButton val = MenuAPI.CreateREPOButton("< Lobby", (Action)ModerationActions.BackToLobby, t, new Vector2(ModStyle.BandLeft, 20f));
				Vector2 labelSize = val.GetLabelSize();
				((Transform)((REPOElement)val).rectTransform).localPosition = new Vector3(ModStyle.ColumnCenter(3, 5) - labelSize.x / 2f, 20f, 0f);
			}
		}

		internal static void Open()
		{
			//IL_01c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Expected O, but got Unknown
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Expected O, but got Unknown
			if (MenuUiHelpers.IsOpenPending)
			{
				return;
			}
			REPOPopupPage page = MenuUiHelpers.CreatePage("Moderation", delegate
			{
			});
			float num = MenuUiHelpers.LayoutScrollMask(page, 42f);
			float tabY = num - 34f;
			IReadOnlyList<string> entries = AuditLog.GetEntries();
			IReadOnlyList<string> readOnlyList = entries;
			if (ModConfig.PersistHistory.Value)
			{
				HashSet<string> excludeKeys = new HashSet<string>(entries);
				List<string> list = AuditStore.PastEntries(ModConfig.PersistedHistoryCount.Value, excludeKeys);
				if (list.Count > 0)
				{
					List<string> list2 = new List<string>(list.Count + entries.Count);
					list2.AddRange(list);
					list2.AddRange(entries);
					readOnlyList = list2;
				}
			}
			int count = readOnlyList.Count;
			MembersPanelController members = new MembersPanelController(page);
			HistoryPageController history = new HistoryPageController(page, readOnlyList);
			TokensPanelController tokens = new TokensPanelController(page);
			SettingsPanelController settings = new SettingsPanelController(page);
			ExtrasPanelController extras = new ExtrasPanelController(page);
			string historyCaption = "History " + ModStyle.CountBadge(count, "0.12em");
			int initialTokenCount = (SemiFunc.IsMasterClient() ? PromotedTokenStore.Entries().Count : ClientTokenStore.Entries().Count);
			REPOButton membersTab = null;
			REPOButton historyTab = null;
			REPOButton tokensTab = null;
			REPOButton settingsTab = null;
			REPOButton extrasTab = null;
			int active = 0;
			if (!SemiFunc.RunIsLobbyMenu())
			{
				REPOPopupPage obj = page;
				object obj2 = <>c.<>9__0_4;
				if (obj2 == null)
				{
					BuilderDelegate val = delegate(Transform t)
					{
						//IL_002b: 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_004a: 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)
						REPOButton val2 = MenuAPI.CreateREPOButton("< Lobby", (Action)ModerationActions.BackToLobby, t, new Vector2(ModStyle.BandLeft, 20f));
						Vector2 labelSize = val2.GetLabelSize();
						((Transform)((REPOElement)val2).rectTransform).localPosition = new Vector3(ModStyle.ColumnCenter(3, 5) - labelSize.x / 2f, 20f, 0f);
					};
					<>c.<>9__0_4 = val;
					obj2 = (object)val;
				}
				obj.AddElement((BuilderDelegate)obj2);
			}
			page.AddElement((BuilderDelegate)delegate(Transform t)
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01da: Unknown result type (might be due to invalid IL or missing references)
				//IL_0204: Unknown result type (might be due to invalid IL or missing references)
				//IL_021d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0263: Unknown result type (might be due to invalid IL or missing references)
				//IL_0268: Unknown result type (might be due to invalid IL or missing references)
				//IL_026f: Unknown result type (might be due to invalid IL or missing references)
				//IL_027f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0285: Unknown result type (might be due to invalid IL or missing references)
				//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
				membersTab = MenuAPI.CreateREPOButton("Members", (Action)delegate
				{
					Select(0);
				}, t, new Vector2(ModStyle.BandLeft, tabY));
				historyTab = MenuAPI.CreateREPOButton(historyCaption, (Action)delegate
				{
					Select(1);
				}, t, new Vector2(ModStyle.BandLeft, tabY));
				tokensTab = MenuAPI.CreateREPOButton(TokensCaption(initialTokenCount), (Action)delegate
				{
					Select(2);
				}, t, new Vector2(ModStyle.BandLeft, tabY));
				settingsTab = MenuAPI.CreateREPOButton("Settings", (Action)delegate
				{
					Select(3);
				}, t, new Vector2(ModStyle.BandLeft, tabY));
				extrasTab = MenuAPI.CreateREPOButton("+", (Action)delegate
				{
					Select(4);
				}, t, new Vector2(ModStyle.BandLeft, tabY));
				REPOButton[] array = (REPOButton[])(object)new REPOButton[4] { membersTab, historyTab, tokensTab, settingsTab };
				float num2 = TabBandLayout.TextColumnWidth(array.Length, ModStyle.BandLeft, ModStyle.BandRight);
				for (int num3 = 0; num3 < array.Length; num3++)
				{
					REPOButton val2 = array[num3];
					((TMP_Text)val2.labelTMP).richText = true;
					((TMP_Text)val2.labelTMP).fontSize = 15f;
					Vector2 labelSize = val2.GetLabelSize();
					float num4 = Mathf.Max(labelSize.x, num2 - 8f);
					val2.overrideButtonSize = new Vector2(num4, labelSize.y);
					((Transform)((REPOElement)val2).rectTransform).localPosition = new Vector3(TabBandLayout.TextTabCenter(num3, array.Length, ModStyle.BandLeft, ModStyle.BandRight) - labelSize.x / 2f, tabY, 0f);
				}
				((TMP_Text)extrasTab.labelTMP).richText = true;
				((TMP_Text)extrasTab.labelTMP).fontSize = 15f;
				Vector2 labelSize2 = extrasTab.GetLabelSize();
				extrasTab.overrideButtonSize = new Vector2(Mathf.Max(labelSize2.x, 18f), labelSize2.y);
				((Transform)((REPOElement)extrasTab).rectTransform).localPosition = new Vector3(TabBandLayout.PlusTabCenter(ModStyle.BandRight) - labelSize2.x / 2f, tabY, 0f);
			});
			members.Build();
			history.Build();
			tokens.Build();
			settings.Build();
			extras.Build();
			tokens.CountChanged = StyleTabs;
			MembersRefresher membersRefresher = ((Component)page).gameObject.AddComponent<MembersRefresher>();
			membersRefresher.OnRefresh = (Action)Delegate.Combine(membersRefresher.OnRefresh, new Action(members.Refresh));
			membersRefresher.OnTick = (Action)Delegate.Combine(membersRefresher.OnTick, new Action(members.TickTalking));
			membersRefresher.OnTick = (Action)Delegate.Combine(membersRefresher.OnTick, new Action(extras.Tick));
			Select(0);
			MenuUiHelpers.OpenPage(page);
			void Select(int which)
			{
				active = which;
				members.SetTabVisible(which == 0);
				history.SetTabVisible(which == 1);
				tokens.SetTabVisible(which == 2);
				settings.SetTabVisible(which == 3);
				extras.SetTabVisible(which == 4);
				StyleTabs();
				page.scrollView.SetScrollPosition(0f);
			}
			void StyleTabs()
			{
				SetTabCaption(membersTab, "Members", active == 0);
				SetTabCaption(historyTab, historyCaption, active == 1);
				SetTabCaption(tokensTab, TokensCaption(tokens.TabCount), active == 2);
				SetTabCaption(settingsTab, "Settings", active == 3);
				SetTabCaption(extrasTab, "+", active == 4);
			}
			static string TokensCaption(int count2)
			{
				return "Access " + ModStyle.CountBadge(count2, "0.12em");
			}
		}

		private static void SetTabCaption(REPOButton? tab, string text, bool activeTab)
		{
			if (!((Object)(object)tab == (Object)null))
			{
				((TMP_Text)tab.labelTMP).text = (activeTab ? ("<color=#66b2ff>" + text + "</color>") : text);
			}
		}
	}
	internal static class ModStyle
	{
		internal const string RoleHostHex = "#ffd24a";

		internal const string RoleModeratorHex = "#66b2ff";

		internal const string RoleModUserHex = "#9bd17a";

		internal const string RoleNoneHex = "#8aa0b0";

		internal static readonly Color RoleHost = Hex(16765514);

		internal static readonly Color RoleModerator = Hex(6730495);

		internal static readonly Color RoleModUser = Hex(10211706);

		internal static readonly Color RoleNone = Hex(9085104);

		internal const string SevFloodHex = "#ff7043";

		internal const string SevMuteHex = "#b57ae0";

		internal const string SevKickHex = "#ef5350";

		internal const string SevBanHex = "#ef5350";

		internal const string SevGrantHex = "#66bb6a";

		internal const string SevRevokeHex = "#ffa726";

		internal const string SevInfoHex = "#8aa0b0";

		internal const string SevAnnounceHex = "#4dd0e1";

		internal static readonly Color SevFlood = Hex(16740419);

		internal static readonly Color SevBan = Hex(15684432);

		internal static readonly Color SevGrant = Hex(6732650);

		internal static readonly Color SevRevoke = Hex(16754470);

		internal static readonly Color SevInfo = Hex(9085104);

		internal static readonly Color SevAnnounce = Hex(5099745);

		internal static readonly Color SevMute = Hex(11893472);

		internal const string PrivateLiveHex = "#4dd07a";

		internal const string PrivateWaitHex = "#e0b84d";

		internal const string PrivateFailHex = "#ef5350";

		internal const string MutedHex = "#ef5350";

		internal static readonly Color ConfirmDanger = new Color(1f, 0.553f, 0f);

		internal static readonly Color ConfirmDestructive = new Color(0.94f, 0.45f, 0.42f);

		internal const string DetailLabelHex = "#8a94a0";

		internal const string DetailValueHex = "#e6eaee";

		internal const string DetailRawHex = "#69737d";

		internal const string ExperimentalHex = "#ffb454";

		internal const string SteamHex = "#66c0f4";

		internal const string DimBodyHex = "#cdd2d8";

		internal const string DimTimeHex = "#9aa4ad";

		internal const string DimFaintHex = "#6f7d88";

		internal static readonly Color NativeAccent = new Color(1f, 0.522f, 0f);

		internal const string NativeAccentHex = "#ff8500";

		internal const float FontHeader = 15f;

		internal const float FontRow = 14f;

		internal const float FontDetail = 14f;

		internal const string SubTextScale = "85%";

		internal const string BadgeScale = "75%";

		internal const string BadgeLiftTab = "0.12em";

		internal const string BadgeLiftHeader = "0.19em";

		internal const float ContentWidth = 250f;

		internal const float PageSpacing = 4f;

		internal const float RowBottomPadding = 2f;

		internal const float LabelBottomPadding = 6f;

		internal const float ButtonPitch = 30f;

		internal const float RowHeight = 24f;

		internal const float MaskBottomY = 56f;

		internal const float TabBandCarve = 42f;

		internal const float TabRowDrop = 34f;

		internal const float TabHitboxGap = 8f;

		internal const float MaskTopFallbackY = 300f;

		internal static float BandLeft = 15f;

		internal static float BandRight = 285f;

		internal const float BandY = 20f;

		internal const int BandColumns = 5;

		internal const int BandColPrev = 0;

		internal const int BandColPage = 1;

		internal const int BandColNext = 2;

		internal const int BandColLobby = 3;

		internal const int BandColClose = 4;

		internal const float TitleAlignOffsetX = 0f;

		internal const float LobbyButtonX = 306f;

		internal const float LobbyButtonBaseY = 90f;

		internal const float EscapeButtonX = 250f;

		internal const float EscapeButtonBaseY = 66f;

		internal static readonly Vector2 ModTitleOffset = new Vector2(14f, 0f);

		internal static readonly Vector2 LobbyModFallback = new Vector2(306f, 120f);

		internal static readonly Vector2 LobbyStartFallback = new Vector2(306f, 90f);

		internal static readonly Vector2 EscapeModFallback = new Vector2(250f, 66f);

		internal static readonly Vector2 ToastPos = new Vector2(40f, 40f);

		internal const float ToastWidth = 560f;

		internal const float ToastRowHeight = 38f;

		internal const float ToastRowPitch = 46f;

		internal const int ToastStackMax = 3;

		internal const float ToastCascade = 0.15f;

		internal const int ToastSortingOrder = 100;

		internal const float ToastFontSize = 20f;

		internal const float ToastBarWidth = 6f;

		internal const float ToastBackingAlpha = 0.6f;

		internal const float ToastDimAlpha = 0.65f;

		internal static readonly Color ToastText = Hex(15133422);

		internal const int PrivateHudSortingOrder = 90;

		internal const float PrivateHudWidth = 240f;

		internal const float PrivateHudTitleHeight = 26f;

		internal const float PrivateHudRowHeight = 28f;

		internal const float PrivateHudRowPitch = 30f;

		internal const float PrivateHudFontSize = 18f;

		internal const float PrivateHudBackingAlpha = 0.55f;

		internal const float PrivateHudSelfBackingAlpha = 0.8f;

		internal const int PrivateHudMaxRows = 8;

		internal const float TalkThreshold = 0.005f;

		internal const float TalkHoldSeconds = 0.18f;

		internal const string TalkDot = "  <color=#d9e8a8>●</color>";

		internal static string CountBadge(int count, string lift)
		{
			return string.Format("<size={0}><voffset={1}>({2})</voffset></size>", "75%", lift, count);
		}

		internal static float ColumnCenter(int index, int columns)
		{
			return BandLeft + ((float)index + 0.5f) * (BandRight - BandLeft) / (float)columns;
		}

		internal static void ConfigureSingleLineEllipsis(TextMeshProUGUI label)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)label).enableWordWrapping = false;
			((TMP_Text)label).overflowMode = (TextOverflowModes)1;
			((TMP_Text)label).margin = new Vector4(0f, 0f - ((TMP_Text)label).fontSize, 0f, 0f - ((TMP_Text)label).fontSize);
		}

		internal static string RoleHex(ModRole role)
		{
			return role switch
			{
				ModRole.Host => "#ffd24a", 
				ModRole.Moderator => "#66b2ff", 
				ModRole.ModUser => "#9bd17a", 
				_ => "#8aa0b0", 
			};
		}

		internal static string RoleLabel(ModRole role)
		{
			return role switch
			{
				ModRole.Host => "Host", 
				ModRole.Moderator => "Moderator", 
				ModRole.ModUser => "Mod user", 
				_ => "No mod", 
			};
		}

		internal static Color KindColor(string? kind)
		{
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			switch (kind)
			{
			case "flood":
			case "kick":
			case "ghostkick":
				return SevFlood;
			case "ban":
			case "ghostban":
				return SevBan;
			case "grant":
				return SevGrant;
			case "revoke":
				return SevRevoke;
			default:
				return SevInfo;
			}
		}

		private static Color Hex(int rgb)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			return new Color((float)((rgb >> 16) & 0xFF) / 255f, (float)((rgb >> 8) & 0xFF) / 255f, (float)(rgb & 0xFF) / 255f);
		}
	}
	internal static class ModUi
	{
		private sealed class ModButtonGate : MonoBehaviour
		{
			private readonly List<(GameObject go, Func<bool> show)> buttons = new List<(GameObject, Func<bool>)>();

			private readonly List<(Transform page, REPOButton button, string seen)> anchors = new List<(Transform, REPOButton, string)>();

			internal void Add(GameObject go, Func<bool> show)
			{
				buttons.Add((go, show));
				go.SetActive(show());
			}

			internal void ReAnchor(Transform page, REPOButton button)
			{
				anchors.Add((page, button, HeaderText(page)));
			}

			private static string HeaderText(Transform page)
			{
				MenuPage val = (((Object)(object)page != (Object)null) ? ((Component)page).GetComponent<MenuPage>() : null);
				if (!((Object)(object)val != (Object)null) || !((Object)(object)val.menuHeader != (Object)null))
				{
					return "";
				}
				return ((TMP_Text)val.menuHeader).text;
			}

			private void Update()
			{
				for (int i = 0; i < buttons.Count; i++)
				{
					var (val, func) = buttons[i];
					if (!((Object)(object)val == (Object)null))
					{
						bool flag = func();
						if (val.activeSelf != flag)
						{
							val.SetActive(flag);
						}
					}
				}
				for (int j = 0; j < anchors.Count; j++)
				{
					var (val2, val3, text) = anchors[j];
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val3 == (Object)null))
					{
						string text2 = HeaderText(val2);
						if (!(text2 == text))
						{
							anchors[j] = (val2, val3, text2);
							AlignModButtonToTitle(val2, val3);
						}
					}
				}
			}
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<bool> <>9__0_2;

			public static Func<bool> <>9__0_3;

			public static Func<bool> <>9__0_4;

			public static BuilderDelegate <>9__0_0;

			public static Func<bool> <>9__0_5;

			public static BuilderDelegate <>9__0_1;

			internal void <Init>b__0_0(Transform parent)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				ModButtonGate modButtonGate = ((Component)parent).gameObject.GetComponent<ModButtonGate>() ?? ((Component)parent).gameObject.AddComponent<ModButtonGate>();
				REPOButton val = MenuAPI.CreateREPOButton("Mod", (Action)ModPanel.Open, parent, ModStyle.LobbyModFallback);
				StyleModButton(val);
				AlignModButtonToTitle(parent, val);
				modButtonGate.Add(((Component)val).gameObject, () => CanModerate);
				modButtonGate.ReAnchor(parent, val);
				GameObject val2 = NativeStartGo(parent);
				if ((Object)(object)val2 != (Object)null)
				{
					modButtonGate.Add(val2, () => !SemiFunc.IsMultiplayer() || SemiFunc.IsMasterClient() || Moderators.Instance.IsModerator(ModerationActions.LocalSteamId));
				}
				else
				{
					REPOButton val3 = MenuAPI.CreateREPOButton("Start game", (Action)ModerationActions.StartGame, parent, ModStyle.LobbyStartFallback);
					modButtonGate.Add(((Component)val3).gameObject, () => !SemiFunc.IsMasterClient() && Moderators.Instance.IsModerator(ModerationActions.LocalSteamId) && !StartCountdown.Active);
				}
				BuildCountdown(parent, val2);
			}

			internal bool <Init>b__0_2()
			{
				return CanModerate;
			}

			internal bool <Init>b__0_3()
			{
				if (SemiFunc.IsMultiplayer() && !SemiFunc.IsMasterClient())
				{
					return Moderators.Instance.IsModerator(ModerationActions.LocalSteamId);
				}
				return true;
			}

			internal bool <Init>b__0_4()
			{
				if (!SemiFunc.IsMasterClient() && Moderators.Instance.IsModerator(ModerationActions.LocalSteamId))
				{
					return !StartCountdown.Active;
				}
				return false;
			}

			internal void <Init>b__0_1(Transform parent)
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				ModButtonGate modButtonGate = ((Component)parent).gameObject.GetComponent<ModButtonGate>() ?? ((Component)parent).gameObject.AddComponent<ModButtonGate>();
				REPOButton val = MenuAPI.CreateREPOButton("Mod", (Action)ModPanel.Open, parent, ModStyle.EscapeModFallback);
				StyleModButton(val);
				AlignModButtonToTitle(parent, val);
				modButtonGate.Add(((Component)val).gameObject, () => CanModerate);
				modButtonGate.ReAnchor(parent, val);
			}

			internal bool <Init>b__0_5()
			{
				return CanModerate;
			}
		}

		private static bool CanModerate => ModerationActions.LocalCanModerate;

		internal static void Init()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			object obj = <>c.<>9__0_0;
			if (obj == null)
			{
				BuilderDelegate val = delegate(Transform parent)
				{
					//IL_003c: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
					ModButtonGate modButtonGate = ((Component)parent).gameObject.GetComponent<ModButtonGate>() ?? ((Component)parent).gameObject.AddComponent<ModButtonGate>();
					REPOButton val3 = MenuAPI.CreateREPOButton("Mod", (Action)ModPanel.Open, parent, ModStyle.LobbyModFallback);
					StyleModButton(val3);
					AlignModButtonToTitle(parent, val3);
					modButtonGate.Add(((Component)val3).gameObject, () => CanModerate);
					modButtonGate.ReAnchor(parent, val3);
					GameObject val4 = NativeStartGo(parent);
					if ((Object)(object)val4 != (Object)null)
					{
						modButtonGate.Add(val4, () => !SemiFunc.IsMultiplayer() || SemiFunc.IsMasterClient() || Moderators.Instance.IsModerator(ModerationActions.LocalSteamId));
					}
					else
					{
						REPOButton val5 = MenuAPI.CreateREPOButton("Start game", (Action)ModerationActions.StartGame, parent, ModStyle.LobbyStartFallback);
						modButtonGate.Add(((Component)val5).gameObject, () => !SemiFunc.IsMasterClient() && Moderators.Instance.IsModerator(ModerationActions.LocalSteamId) && !StartCountdown.Active);
					}
					BuildCountdown(parent, val4);
				};
				<>c.<>9__0_0 = val;
				obj = (object)val;
			}
			MenuAPI.AddElementToLobbyMenu((BuilderDelegate)obj);
			object obj2 = <>c.<>9__0_1;
			if (obj2 == null)
			{
				BuilderDelegate val2 = delegate(Transform parent)
				{
					//IL_003c: Unknown result type (might be due to invalid IL or missing references)
					ModButtonGate modButtonGate = ((Component)parent).gameObject.GetComponent<ModButtonGate>() ?? ((Component)parent).gameObject.AddComponent<ModButtonGate>();
					REPOButton val3 = MenuAPI.CreateREPOButton("Mod", (Action)ModPanel.Open, parent, ModStyle.EscapeModFallback);
					StyleModButton(val3);
					AlignModButtonToTitle(parent, val3);
					modButtonGate.Add(((Component)val3).gameObject, () => CanModerate);
					modButtonGate.ReAnchor(parent, val3);
				};
				<>c.<>9__0_1 = val2;
				obj2 = (object)val2;
			}
			MenuAPI.AddElementToEscapeMenu((BuilderDelegate)obj2);
			Plugin.Logger.LogInfo((object)"Native moderation UI initialized");
		}

		private static void AlignModButtonToTitle(Transform page, REPOButton button)
		{
			try
			{
				AlignToTitleRaw(page, button);
			}
			catch
			{
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void AlignToTitleRaw(Transform page, REPOButton button)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: 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)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			MenuPage component = ((Component)page).GetComponent<MenuPage>();
			if (!((Object)(object)component == (Object)null) && !((Object)(object)component.menuHeader == (Object)null))
			{
				TextMeshProUGUI menuHeader = component.menuHeader;
				((TMP_Text)menuHeader).ForceMeshUpdate(false, false);
				Bounds textBounds = ((TMP_Text)menuHeader).textBounds;
				Vector3 val;
				if (((Bounds)(ref textBounds)).extents.x > 0f)
				{
					val = ((TMP_Text)menuHeader).transform.TransformPoint(new Vector3(((Bounds)(ref textBounds)).max.x, ((Bounds)(ref textBounds)).center.y, 0f));
				}
				else
				{
					Rect rect = ((TMP_Text)menuHeader).rectTransform.rect;
					val = ((Transform)((TMP_Text)menuHeader).rectTransform).TransformPoint(new Vector3(((Rect)(ref rect)).xMax, ((Rect)(ref rect)).center.y, 0f));
				}
				Vector3 val2 = page.InverseTransformPoint(val);
				Vector2 labelSize = button.GetLabelSize();
				((Transform)((REPOElement)button).rectTransform).localPosition = new Vector3(val2.x + ModStyle.ModTitleOffset.x, val2.y - labelSize.y / 2f + ModStyle.ModTitleOffset.y, 0f);
			}
		}

		private static void BuildCountdown(Transform page, GameObject? nativeStart)
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = null;
			CanvasGroup fade = null;
			TMP_Text val2 = null;
			if ((Object)(object)nativeStart != (Object)null)
			{
				try
				{
					(val, fade, val2) = BuildCountdownSlotRaw(nativeStart);
				}
				catch
				{
					val = null;
					fade = null;
					val2 = null;
				}
			}
			bool richAccent = false;
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				REPOButton val3 = MenuAPI.CreateREPOButton("Starts in 5", (Action)CancelCountdownIfAllowed, page, ModStyle.LobbyStartFallback);
				((REPOElement)val3).rectTransform.pivot = new Vector2(0.5f, 0.5f);
				((TMP_Text)val3.labelTMP).richText = true;
				val = ((Component)val3).gameObject;
				val2 = (TMP_Text)(object)val3.labelTMP;
				richAccent = true;
			}
			val.SetActive(false);
			((Component)page).gameObject.AddComponent<StartCountdownDisplay>().Wire(val, fade, val2, richAccent, nativeStart);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static (GameObject root, CanvasGroup fade, TMP_Text label) BuildCountdownSlotRaw(GameObject nativeStart)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			//IL_0052: 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)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			RectTransform val = (RectTransform)nativeStart.transform;
			GameObject val2 = new GameObject("SharePermissions Countdown", new Type[2]
			{
				typeof(RectTransform),
				typeof(CanvasGroup)
			});
			RectTransform val3 = (RectTransform)val2.transform;
			((Transform)val3).SetParent(((Transform)val).parent, false);
			val3.anchorMin = val.anchorMin;
			val3.anchorMax = val.anchorMax;
			val3.pivot = val.pivot;
			val3.anchoredPosition = val.anchoredPosition;
			val3.sizeDelta = val.sizeDelta;
			((Transform)val3).localScale = ((Transform)val).localScale;
			((Transform)val3).localRotation = ((Transform)val).localRotation;
			TextMeshProUGUI componentInChildren = nativeStart.GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren == (Object)null)
			{
				throw new InvalidOperationException("native Start button has no label");
			}
			GameObject val4 = Object.Instantiate<GameObject>(((Component)componentInChildren).gameObject, (Transform)(object)val3);
			((Object)val4).name = "Countdown Label";
			LocalizationChangedEvent[] componentsInChildren = val4.GetComponentsInChildren<LocalizationChangedEvent>(true);
			foreach (LocalizationChangedEvent val5 in componentsInChildren)
			{
				val5.localizedAsset = null;
			}
			Component[] components = val4.GetComponents<Component>();
			foreach (Component val6 in components)
			{
				if ((!(val6 is RectTransform) && !(val6 is CanvasRenderer) && !(val6 is TMP_Text)) || 1 == 0)
				{
					Object.Destroy((Object)(object)val6);
				}
			}
			foreach (Transform item in val4.transform)
			{
				Transform val7 = item;
				Object.Destroy((Object)(object)((Component)val7).gameObject);
			}
			TextMeshProUGUI component = val4.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = "Starts in 5";
			((Graphic)component).color = ModStyle.NativeAccent;
			return (root: val2, fade: val2.GetComponent<CanvasGroup>(), label: (TMP_Text)(object)component);
		}

		private static GameObject? NativeStartGo(Transform page)
		{
			try
			{
				return NativeStartGoRaw(page);
			}
			catch
			{
				return null;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static GameObject? NativeStartGoRaw(Transform page)
		{
			MenuPageLobby component = ((Component)page).GetComponent<MenuPageLobby>();
			if (!((Object)(object)component != (Object)null) || !((Object)(object)component.startButton != (Object)null))
			{
				return null;
			}
			return ((Component)component.startButton).gameObject;
		}

		private static void CancelCountdownIfAllowed()
		{
			if (CanModerate)
			{
				StartCountdown.RequestCancelFromUi();
			}
		}

		private static void StyleModButton(REPOButton button)
		{
			((TMP_Text)button.labelTMP).richText = true;
			((TMP_Text)button.labelTMP).text = "<color=#66b2ff>Mod</color>";
		}
	}
	internal static class NativeKickButton
	{
		internal static GameObject CreateX(GameObject nativeKickGo, Action onClick)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Expected O, but got Unknown
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(nativeKickGo, nativeKickGo.transform.parent);
			((Object)val).name = "SharePermissions_XKick";
			val.SetActive(true);
			RectTransform val2 = null;
			MenuButtonKick component = val.GetComponent<MenuButtonKick>();
			if (component != null)
			{
				val2 = component.backgroundRect;
				Object.Destroy((Object)(object)component);
			}
			MenuButtonPopUp componentInChildren = val.GetComponentInChildren<MenuButtonPopUp>(true);
			if (componentInChildren != null)
			{
				Object.Destroy((Object)(object)componentInChildren);
			}
			MenuButton componentInChildren2 = val.GetComponentInChildren<MenuButton>(true);
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				componentInChildren2.buttonTextString = "x";
				if ((Object)(object)componentInChildren2.buttonText != (Object)null)
				{
					((TMP_Text)componentInChildren2.buttonText).text = "x";
					componentInChildren2.ResizeToText();
				}
			}
			Button componentInChildren3 = val.GetComponentInChildren<Button>(true);
			if ((Object)(object)componentInChildren3 != (Object)null)
			{
				((UnityEventBase)componentInChildren3.onClick).RemoveAllListeners();
				((UnityEvent)componentInChildren3.onClick).AddListener((UnityAction)delegate
				{
					onClick();
				});
			}
			if ((Object)(object)val2 != (Object)null)
			{
				((Transform)val2).localScale = Vector3.one;
			}
			CanvasGroup[] componentsInChildren = val.GetComponentsInChildren<CanvasGroup>(true);
			foreach (CanvasGroup val3 in componentsInChildren)
			{
				val3.alpha = 1f;
			}
			return val;
		}
	}
	internal static class NotesJoinToast
	{
		private static readonly HashSet<int> toastedActors = new HashSet<int>();

		internal static void Reset()
		{
			toastedActors.Clear();
		}

		internal static void OnPlayerSeen(Player? player)
		{
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (player == null || player.IsLocal || toastedActors.Contains(player.ActorNumber) || !ModerationActions.LocalCanModerate)
				{
					return;
				}
				string text = PlayerRegistry.Instance.Resolve(player.ActorNumber);
				if (!string.IsNullOrEmpty(text))
				{
					toastedActors.Add(player.ActorNumber);
					int num = NotesStore.CountFor(text);
					if (num != 0)
					{
						string arg = MenuUiHelpers.SanitizePlayerName(player.NickName, $"Player_{player.ActorNumber}");
						NotificationCenter.EnqueueDirect(string.Format("{0} joined - {1} note{2}", arg, num, (num == 1) ? "" : "s"), ModStyle.SevInfo);
					}
				}
			}
			catch (Exception arg2)
			{
				Plugin.Logger.LogWarning((object)$"[SharePermissions] Notes join toast failed: {arg2}");
			}
		}
	}
	internal static class NotificationCenter
	{
		private const int QueueCap = 8;

		private const float GraceSeconds = 10f;

		private static readonly Queue<(string Text, Color Color)> queue = new Queue<(string, Color)>();

		private static bool initialized;

		private static bool? localWasModerator;

		private static float joinedAt = float.NegativeInfinity;

		private static readonly Regex TimePrefix = new Regex("^\\[\\d{2}:\\d{2}:\\d{2}\\]\\s*", RegexOptions.Compiled);

		private static readonly Regex MetaTail = new Regex("\\s*\\[[^\\[\\]]*\\]\\s*$", RegexOptions.Compiled);

		internal static void Init()
		{
			if (!initialized)
			{
				initialized = true;
				AuditLog.EntryWritten += OnEntryWritten;
				Moderators.Instance.Changed += OnModeratorsChanged;
			}
		}

		private static void OnEntryWritten(string entry, string kind)
		{
			OnAuditEntry(entry, kind);
		}

		internal static void OnAuditEntry(string entry, string kind)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (kind == "none")
			{
				return;
			}
			try
			{
				Enqueue(CoreSentence(entry), ModStyle.KindColor(kind));
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogWarning((object)$"[SharePermissions] Notification handling failed: {arg}");
			}
		}

		private static void OnModeratorsChanged()
		{
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!PhotonNetwork.InRoom)
				{
					localWasModerator = null;
					return;
				}
				bool flag = Moderators.Instance.IsModerator(ModerationActions.LocalSteamId);
				if (!localWasModerator.HasValue)
				{
					localWasModerator = flag;
				}
				else
				{
					if (flag == localWasModerator.Value)
					{
						return;
					}
					localWasModerator = flag;
					if (!(Time.unscaledTime - joinedAt < 10f))
					{
						if (flag)
						{
							Enqueue("You are now a moderator", ModStyle.RoleModerator);
						}
						else
						{
							Enqueue("Your moderator role was revoked", ModStyle.SevRevoke);
						}
					}
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogWarning((object)$"[SharePermissions] Notification handling failed: {arg}");
			}
		}

		internal static void ArmSession()
		{
			joinedAt = Time.unscaledTime;
			localWasModerator = false;
		}

		internal static void RestampGrace()
		{
			joinedAt = Time.unscaledTime;
		}

		internal static void ResetSession()
		{
			queue.Clear();
			localWasModerator = null;
			joinedAt = float.NegativeInfinity;
		}

		private static void Enqueue(string text, Color color)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.ShowNotifications.Value && !string.IsNullOrWhiteSpace(text))
			{
				queue.Enqueue((text, color));
				while (queue.Count > 8)
				{
					queue.Dequeue();
				}
			}
		}

		internal static void EnqueueDirect(string text, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Enqueue(text, color);
		}

		internal static bool TryTake(out (string Text, Color Color) toast)
		{
			toast = default((string, Color));
			if (queue.Count == 0)
			{
				return false;
			}
			toast = queue.Dequeue();
			return true;
		}

		private static string CoreSentence(string entry)
		{
			string input = TimePrefix.Replace(entry ?? "", "");
			input = MetaTail.Replace(input, "");
			return MenuUiHelpers.StripRichText(input).Trim();
		}
	}
	internal sealed class NotificationOverlay : MonoBehaviour
	{
		private sealed class ToastRow
		{
			private readonly RectTransform rect;

			private readonly CanvasGroup group;

			private readonly Image bar;

			private readonly TextMeshProUGUI label;

			private float elapsed = -1f;

			private float holdSeconds;

			internal long Order { get; private set; }

			internal bool Live => elapsed >= 0f;

			internal string FontName
			{
				get
				{
					if (!((Object)(object)((TMP_Text)label).font != (Object)null))
					{
						return "<null>";
					}
					return ((Object)((TMP_Text)label).font).name;
				}
			}

			private ToastRow(RectTransform rect, CanvasGroup group, Image bar, TextMeshProUGUI label)
			{
				this.rect = rect;
				this.group = group;
				this.bar = bar;
				this.label = label;
			}

			internal static ToastRow Build(Transform parent, int index)
			{
				//IL_0030: Unknown result type (might be due to invalid IL or missing references)
				//IL_0036: Expected O, but got Unknown
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Expected O, but got Unknown
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Unknown result type (might be due to invalid IL or missing references)
				//IL_0076: Unknown result type (might be due to invalid IL or missing references)
				//IL_009e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: 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_0104: 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_0138: Unknown result type (might be due to invalid IL or missing references)
				//IL_0152: Unknown result type (might be due to invalid IL or missing references)
				//IL_0162: Unknown result type (might be due to invalid IL or missing references)
				//IL_0184: Unknown result type (might be due to invalid IL or missing references)
				//IL_018b: Expected O, but got Unknown
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_0199: Expected O, but got Unknown
				//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject($"Toast{index}", new Type[2]
				{
					typeof(RectTransform),
					typeof(CanvasGroup)
				});
				RectTransform val2 = (RectTransform)val.transform;
				((Transform)val2).SetParent(parent, false);
				val2.anchorMin = Vector2.zero;
				val2.anchorMax = Vector2.zero;
				val2.pivot = Vector2.zero;
				val2.sizeDelta = new Vector2(560f, 38f);
				val2.anchoredPosition = new Vector2(ModStyle.ToastPos.x, ModStyle.ToastPos.y + (float)index * 46f);
				Image val3 = NewChildImage(val2, "Backing");
				Stretch(((Graphic)val3).rectTransform, Vector2.zero, Vector2.zero);
				((Graphic)val3).color = new Color(0f, 0f, 0f, 0.6f);
				Image val4 = NewChildImage(val2, "Bar");
				((Graphic)val4).rectTransform.anchorMin = new Vector2(0f, 0f);
				((Graphic)val4).rectTransform.anchorMax = new Vector2(0f, 1f);
				((Graphic)val4).rectTransform.pivot = new Vector2(0f, 0.5f);
				((Graphic)val4).rectTransform.sizeDelta = new Vector2(6f, 0f);
				((Graphic)val4).rectTransform.anchoredPosition = Vector2.zero;
				GameObject val5 = new GameObject("Label", new Type[1] { typeof(RectTransform) });
				RectTransform val6 = (RectTransform)val5.transform;
				((Transform)val6).SetParent((Transform)(object)val2, false);
				Stretch(val6, new Vector2(18f, 3f), new Vector2(-10f, -3f));
				TextMeshProUGUI val7 = val5.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val7).fontSize = 20f;
				((Graphic)val7).color = ModStyle.ToastText;
				((TMP_Text)val7).alignment = (TextAlignmentOptions)4097;
				ModStyle.ConfigureSingleLineEllipsis(val7);
				((Graphic)val7).raycastTarget = false;
				ToastRow result = new ToastRow(val2, val.GetComponent<CanvasGroup>(), val4, val7);
				val.SetActive(false);
				return result;
			}

			private static Image NewChildImage(RectTransform parent, string name)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Expected O, but got Unknown
				GameObject val = new GameObject(name, new Type[1] { typeof(RectTransform) });
				val.transform.SetParent((Transform)(object)parent, false);
				Image val2 = val.AddComponent<Image>();
				((Graphic)val2).raycastTarget = false;
				return val2;
			}

			private static void Stretch(RectTransform rect, Vector2 offsetMin, Vector2 offsetMax)
			{
				//IL_0001: 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_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				rect.anchorMin = Vector2.zero;
				rect.anchorMax = Vector2.one;
				rect.offsetMin = offsetMin;
				rect.offsetMax = offsetMax;
			}

			internal void ApplyFont(TMP_FontAsset font)
			{
				((TMP_Text)label).font = font;
				((TMP_Text)label).ForceMeshUpdate(true, true);
			}

			internal void Show(string text, Color color, float seconds, long order, int spawnSlot)
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Unknown result type (might be due to invalid IL or missing references)
				((TMP_Text)label).text = text;
				((Graphic)bar).color = color;
				holdSeconds = seconds;
				Order = order;
				elapsed = 0f;
				group.alpha = 0f;
				((Transform)rect).localScale = Vector3.one;
				((Component)rect).gameObject.SetActive(true);
				rect.anchoredPosition = new Vector2(ModStyle.ToastPos.x - 32f, ModStyle.ToastPos.y + (float)spawnSlot * 46f);
			}

			internal void HideImmediate()
			{
				elapsed = -1f;
				((Component)rect).gameObject.SetActive(false);
			}

			internal void LogGlyphDiagnostic()
			{
				OverlayFont.LogGlyphDiagnostic(label, "toast");
			}

			internal void Tick(int slot, bool newest)
			{
				//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_0114: Unknown result type (might be due to invalid IL or missing references)
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01de: Unknown result type (might be due to invalid IL or missing references)
				if (!Live)
				{
					return;
				}
				elapsed += Time.unscaledDeltaTime;
				if (elapsed >= holdSeconds + 0.3f)
				{
					HideImmediate();
					return;
				}
				float num3;
				if (elapsed < 0.35f)
				{
					float num = Mathf.Clamp01(elapsed / 0.35f) - 1f;
					float num2 = 1f + 2.70158f * num * num * num + 1.70158f * num * num;
					num3 = -32f * (1f - num2);
					((Transform)rect).localScale = new Vector3(1f, Mathf.LerpUnclamped(0.4f, 1f, num2), 1f);
					float num4 = 1f;
					group.alpha = Mathf.Clamp01(elapsed / 0.175f);
				}
				else if (elapsed >= holdSeconds)
				{
					float num5 = (elapsed - holdSeconds) / 0.3f;
					num3 = -10f * num5;
					((Transform)rect).localScale = Vector3.one;
					float num4 = 0f;
					group.alpha = Mathf.Lerp(group.alpha, 0f, num5);
				}
				else
				{
					num3 = 0f;
					((Transform)rect).localScale = Vector3.one;
					float num4 = (newest ? 1f : 0.65f);
					group.alpha = Mathf.Lerp(group.alpha, num4, Time.unscaledDeltaTime * 10f);
				}
				float num6 = ModStyle.ToastPos.y + (float)slot * 46f;
				float num7 = Mathf.Lerp(rect.anchoredPosition.y, num6, Time.unscaledDeltaTime * 10f);
				rect.anchoredPosition = new Vector2(ModStyle.ToastPos.x + num3, num7);
			}
		}

		private const float AppearSeconds = 0.35f;

		private const float DepartSeconds = 0.3f;

		private const float SettleLerp = 10f;

		private const float SlideInPx = 32f;

		private static NotificationOverlay? instance;

		private readonly ToastRow[] rows = new ToastRow[3];

		private float nextTakeAt;

		private int fontGeneration = -1;

		private long orderCounter;

		private ToastRow? diagRow;

		private int diagFrame;

		internal static void Init()
		{
			//IL_0013: 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_0021: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)instance != (Object)null))
			{
				GameObject val = new GameObject("SharePermissionsToasts")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)(object)val);
				OverlayFont.RegisterOwnRoot(val.transform);
				Canvas val2 = val.AddComponent<Canvas>();
				val2.renderMode = (RenderMode)0;
				val2.sortingOrder = 100;
				CanvasScaler val3 = val.AddComponent<CanvasScaler>();
				val3.uiScaleMode = (ScaleMode)1;
				val3.referenceResolution = new Vector2(1920f, 1080f);
				val3.matchWidthOrHeight = 1f;
				instance = val.AddComponent<NotificationOverlay>();
				for (int i = 0; i < instance.rows.Length; i++)
				{
					instance.rows[i] = ToastRow.Build(val.transform, i);
				}
			}
		}

		private void Update()
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			OverlayFont.Pump();
			if (!ModConfig.ShowNotifications.Value)
			{
				(string, Color) toast;
				while (NotificationCenter.TryTake(out toast))
				{
				}
				ToastRow[] array = rows;
				foreach (ToastRow toastRow in array)
				{
					toastRow.HideImmediate();
				}
				return;
			}
			if (diagRow != null && Time.frameCount >= diagFrame)
			{
				ToastRow toastRow2 = diagRow;
				diagRow = null;
				toastRow2.LogGlyphDiagnostic();
			}
			if (OverlayFont.Generation != fontGeneration)
			{
				fontGeneration = OverlayFont.Generation;
				TMP_FontAsset font = OverlayFont.Font;
				if ((Object)(object)font != (Object)null)
				{
					ToastRow[] array2 = rows;
					foreach (ToastRow toastRow3 in array2)
					{
						toastRow3.ApplyFont(font);
					}
				}
			}
			if (Time.unscaledTime >= nextTakeAt)
			{
				ToastRow toastRow4 = FreeRow();
				if (toastRow4 != null && NotificationCenter.TryTake(out (string, Color) toast2))
				{
					int num = 0;
					ToastRow[] array3 = rows;
					foreach (ToastRow toastRow5 in array3)
					{
						if (toastRow5.Live)
						{
							num++;
						}
					}
					toastRow4.Show(toast2.Item1, toast2.Item2, ModConfig.NotificationSeconds.Value, ++orderCounter, num);
					if (OverlayFont.WarnDefaultOnce())
					{
						bool flag = false;
						string item = toast2.Item1;
						foreach (char c in item)
						{
							if (c > '\u007f')
							{
								flag = true;
								break;
							}
						}
						Plugin.Logger.LogInfo((object)$"[SharePermissions] Toast shown before the native font resolved - using the TMP default until it does (hasNonAscii={flag} defaultFont={toastRow4.FontName})");
					}
					if (diagRow == null && OverlayFont.WantsGlyphDiagnostic(toast2.Item1, "toast"))
					{
						diagRow = toastRow4;
						diagFrame = Time.frameCount + 2;
					}
					nextTakeAt = Time.unscaledTime + 0.15f;
				}
			}
			long num2 = long.MinValue;
			ToastRow[] array4 = rows;
			foreach (ToastRow toastRow6 in array4)
			{
				if (toastRow6.Live && toastRow6.Order > num2)
				{
					num2 = toastRow6.Order;
				}
			}
			ToastRow[] array5 = rows;
			foreach (ToastRow toastRow7 in array5)
			{
				if (!toastRow7.Live)
				{
					toastRow7.Tick(0, newest: false);
					continue;
				}
				int num3 = 0;
				ToastRow[] array6 = rows;
				foreach (ToastRow toastRow8 in array6)
				{
					if (toastRow8.Live && toastRow8.Order < toastRow7.Order)
					{
						num3++;
					}
				}
				toastRow7.Tick(num3, toastRow7.Order == num2);
			}
		}

		private ToastRow? FreeRow()
		{
			ToastRow[] array = rows;
			foreach (ToastRow toastRow in array)
			{
				if (!toastRow.Live)
				{
					return toastRow;
				}
			}
			return null;
		}
	}
	internal static class OverlayFont
	{
		private static TMP_FontAsset? nativeFont;

		private static Material? nativeFontMaterial;

		private static bool defaultLogged;

		private static bool fallbackRegistered;

		private static float nextProbeAt;

		private static readonly string[] FallbackOsFonts = new string[3] { "Segoe UI", "Arial", "Tahoma" };

		private static readonly string CyrillicAlphabet = BuildCyrillicAlphabet();

		private static readonly List<Transform> ownRoots = new List<Transform>();

		private static readonly int MainTexId = Shader.PropertyToID("_MainTex");

		private static readonly HashSet<string> diagDoneSurfaces = new HashSet<string>();

		internal static TMP_FontAsset? Font => nativeFont;

		internal static int Generation { get; private set; }

		private static string BuildCyrillicAlphabet()
		{
			StringBuilder stringBuilder = new StringBuilder();
			for (int i = 1040; i <= 1103; i++)
			{
				stringBuilder.Append((char)i);
			}
			stringBuilder.Append('Ё').Append('ё');
			return stringBuilder.ToString();
		}

		internal static void RegisterOwnRoot(Transform root)
		{
			if ((Object)(object)root != (Object)null && !ownRoots.Contains(root))
			{
				ownRoots.Add(root);
			}
		}

		internal static bool WarnDefaultOnce()
		{
			if ((Object)(object)nativeFont != (Object)null || defaultLogged)
			{
				return false;
			}
			defaultLogged = true;
			return true;
		}

		internal static void Pump()
		{
			if ((Object)(object)nativeFont != (Object)null || Time.unscaledTime < nextProbeAt)
			{
				return;
			}
			nextProbeAt = Time.unscaledTime + 0.5f;
			try
			{
				ResolveRaw();
			}
			catch
			{
			}
			if ((Object)(object)nativeFont != (Object)null)
			{
				try
				{
					RegisterGlobalFallbackRaw();
				}
				catch
				{
				}
				Generation++;
				Plugin.Logger.LogInfo((object)("[SharePermissions] Overlay font resolved: " + ((Object)nativeFont).name));
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ResolveRaw()
		{
			TMP_FontAsset val = null;
			TextMeshProUGUI[] array = Object.FindObjectsOfType<TextMeshProUGUI>();
			foreach (TextMeshProUGUI val2 in array)
			{
				if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((TMP_Text)val2).font == (Object)null) && !((Object)(object)((TMP_Asset)((TMP_Text)val2).font).material == (Object)null) && !IsOwnLabel(((TMP_Text)val2).transform))
				{
					if (val == null)
					{
						val = ((TMP_Text)val2).font;
					}
					if ((Object)(object)((TMP_Text)val2).fontSharedMaterial != (Object)null && ((Object)((TMP_Text)val2).fontSharedMaterial).GetInstanceID() == ((Object)((TMP_Asset)((TMP_Text)val2).font).material).GetInstanceID())
					{
						nativeFont = ((TMP_Text)val2).font;
						nativeFontMaterial = ((TMP_Asset)((TMP_Text)val2).font).material;
						return;
					}
				}
			}
			if (!((Object)(object)val == (Object)null))
			{
				nativeFont = val;
				nativeFontMaterial = ((TMP_Asset)val).material;
			}
		}

		private static bool IsOwnLabel(Transform t)
		{
			foreach (Transform ownRoot in ownRoots)
			{
				if ((Object)(object)ownRoot != (Object)null && t.IsChildOf(ownRoot))
				{
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void RegisterGlobalFallbackRaw()
		{
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0267: Unknown result type (might be due to invalid IL or missing references)
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0307: Unknown result type (might be due to invalid IL or missing references)
			if (fallbackRegistered || (Object)(object)nativeFont == (Object)null)
			{
				return;
			}
			fallbackRegistered = true;
			string[] oSInstalledFontNames = Font.GetOSInstalledFontNames();
			string[] pathsToOSFonts = Font.GetPathsToOSFonts();
			Plugin.Logger.LogInfo((object)$"[SharePermissions] OS installed font count: {oSInstalledFontNames.Length} names, {pathsToOSFonts.Length} paths");
			try
			{
				List<TMP_FontAsset> fallbackFontAssetTable = nativeFont.fallbackFontAssetTable;
				StringBuilder stringBuilder = new StringBuilder();
				if (fallbackFontAssetTable != null)
				{
					foreach (TMP_FontAsset item in fallbackFontAssetTable)
					{
						if (!((Object)(object)item == (Object)null))
						{
							if (stringBuilder.Length > 0)
							{
								stringBuilder.Append(", ");
							}
							stringBuilder.Append($"{FontAssetLabel(item)}(mode={item.atlasPopulationMode} cyr={item.HasCharacter('й', false, false)})");
						}
					}
				}
				Plugin.Logger.LogInfo((object)$"[SharePermissions] Game font own fallback chain: [{stringBuilder}]");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogInfo((object)("[SharePermissions] Chain dump failed: " + ex.Message));
			}
			string[] fallbackOsFonts = FallbackOsFonts;
			string text3 = default(string);
			foreach (string text in fallbackOsFonts)
			{
				string text2 = ResolveInstalledPath(pathsToOSFonts, text);
				if (text2 == null)
				{
					Plugin.Logger.LogInfo((object)("[SharePermissions] Overlay fallback candidate has no matching OS font file: " + text));
					continue;
				}
				Font val = new Font();
				try
				{
					Font.Internal_CreateFontFromPath(val, text2);
				}
				catch (Exception ex2)
				{
					Plugin.Logger.LogInfo((object)("[SharePermissions] Internal_CreateFontFromPath threw for " + text2 + ": " + ex2.Message));
					Object.Destroy((Object)(object)val);
					continue;
				}
				TMP_FontAsset val2 = TMP_FontAsset.CreateFontAsset(val);
				if ((Object)(object)val2 == (Object)null)
				{
					Plugin.Logger.LogInfo((object)("[SharePermissions] CreateFontAsset returned null: " + text2));
					Object.Destroy((Object)(object)val);
					continue;
				}
				((Object)val2).hideFlags = (HideFlags)61;
				((Object)val2).name = "SP-CyrillicFallback";
				if ((Object)(object)nativeFontMaterial != (Object)null && (Object)(object)((TMP_Asset)val2).material != (Object)null)
				{
					((TMP_Asset)val2).material.shader = nativeFontMaterial.shader;
				}
				if (!val2.TryAddCharacters(CyrillicAlphabet, ref text3, false))
				{
					Plugin.Logger.LogInfo((object)("[SharePermissions] Resolved OS font missing Cyrillic characters [" + text3 + "]: " + text2));
					Object.Destroy((Object)(object)val2);
					Object.Destroy((Object)(object)val);
					continue;
				}
				try
				{
					FaceInfo faceInfo = nativeFont.faceInfo;
					FaceInfo faceInfo2 = val2.faceInfo;
					if (((FaceInfo)(ref faceInfo)).pointSize > 0 && ((FaceInfo)(ref faceInfo2)).pointSize > 0)
					{
						float num = ((FaceInfo)(ref faceInfo)).ascentLine / (float)((FaceInfo)(ref faceInfo)).pointSize;
						float num2 = ((FaceInfo)(ref faceInfo)).descentLine / (float)((FaceInfo)(ref faceInfo)).pointSize;
						bool flag = false;
						if (((FaceInfo)(ref faceInfo2)).ascentLine / (float)((FaceInfo)(ref faceInfo2)).pointSize > num)
						{
							((FaceInfo)(ref faceInfo2)).ascentLine = num * (float)((FaceInfo)(ref faceInfo2)).pointSize;
							flag = true;
						}
						if (((FaceInfo)(ref faceInfo2)).descentLine / (float)((FaceInfo)(ref faceInfo2)).pointSize < num2)
						{
							((FaceInfo)(ref faceInfo2)).descentLine = num2 * (float)((FaceInfo)(ref faceInfo2)).pointSize;
							flag = true;
						}
						if (flag)
						{
							val2.faceInfo = faceInfo2;
							Plugin.Logger.LogInfo((object)$"[SharePermissions] Fallback face clamped to the native face: asc={((FaceInfo)(ref faceInfo2)).ascentLine:0.##} desc={((FaceInfo)(ref faceInfo2)).descentLine:0.##} @ {((FaceInfo)(ref faceInfo2)).pointSize}pt");
						}
					}
				}
				catch (Exception ex3)
				{
					Plugin.Logger.LogInfo((object)("[SharePermissions] Fallback face clamp skipped: " + ex3.Message));
				}
				if (!AddToGlobalFallbacks(val2))
				{
					Plugin.Logger.LogInfo((object)("[SharePermissions] Could not reach TMP_Settings.fallbackFontAssets - Cyrillic stays unavailable: " + text2));
					Object.Destroy((Object)(object)val2);
					Object.Destroy((Object)(object)val);
					continue;
				}
				ManualLogSource logger = Plugin.Logger;
				string[] obj = new string[6] { "[SharePermissions] Cyrillic fallback font registered globally: ", text2, " ", null, null, null };
				object arg = val2.characterTable.Count;
				FaceInfo faceInfo3 = val2.faceInfo;
				obj[3] = $"(chars={arg} pointSize={((FaceInfo)(ref faceInfo3)).pointSize} ";
				obj[4] = $"globalList=[{DescribeGlobalFallbacks()}] matchMaterialPreset={TMP_Settings.matchMaterialPreset} ";
				obj[5] = $"warningsDisabled={TMP_Settings.warningsDisabled})";
				logger.LogInfo((object)string.Concat(obj));
				return;
			}
			Plugin.Logger.LogInfo((object)"[SharePermissions] No OS fallback font found - overlays render with the game font only");
		}

		private static bool AddToGlobalFallbacks(TMP_FontAsset fallback)
		{
			List<TMP_FontAsset> list = TMP_Settings.fallbackFontAssets;
			if (list == null)
			{
				TMP_Settings instance = TMP_Settings.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return false;
				}
				FieldInfo field = typeof(TMP_Settings).GetField("m_fallbackFontAssets", BindingFlags.Instance | BindingFlags.NonPublic);
				if (field == null)
				{
					return false;
				}
				list = new List<TMP_FontAsset>();
				field.SetValue(instance, list);
			}
			if (!list.Contains(fallback))
			{
				list.Insert(0, fallback);
			}
			return true;
		}

		private static string DescribeGlobalFallbacks()
		{
			List<TMP_FontAsset> fallbackFontAssets = TMP_Settings.fallbackFontAssets;
			if (fallbackFontAssets == null)
			{
				return "<null>";
			}
			StringBuilder stringBuilder = new StringBuilder(fallbackFontAssets.Count * 32);
			stringBuilder.Append("n=").Append(fallbackFontAssets.Count);
			for (int i = 0; i < fallbackFontAssets.Count; i++)
			{
				stringBuilder.Append((i == 0) ? ": " : ", ");
				TMP_FontAsset val = fallbackFontAssets[i];
				stringBuilder.Append(((Object)(object)val == (Object)null) ? "<null>" : $"{FontAssetLabel(val)}(id={((Object)val).GetInstanceID()} chars={val.characterTable.Count})");
			}
			return stringBuilder.ToString();
		}

		private static string FontAssetLabel(TMP_FontAsset fa)
		{
			if (!string.IsNullOrEmpty(((Object)fa).name))
			{
				return ((Object)fa).name;
			}
			return "<unnamed>";
		}

		internal static bool WantsGlyphDiagnostic(string? text, string surface)
		{
			if (string.IsNullOrEmpty(text) || diagDoneSurfaces.Contains(surface))
			{
				return false;
			}
			for (int i = 0; i < text.Length; i++)
			{
				if (text[i] > '\u007f')
				{
					return true;
				}
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void LogGlyphDiagnostic(TextMeshProUGUI label, string surface)
		{
			//IL_00fe: 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_0159: 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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_060c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0611: Unknown result type (might be due to invalid IL or missing references)
			//IL_0613: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Unknown result type (might be due to invalid IL or missing references)
			if (!diagDoneSurfaces.Add(surface))
			{
				return;
			}
			try
			{
				TMP_TextInfo textInfo = ((TMP_Text)label).textInfo;
				TMP_FontAsset font = ((TMP_Text)label).font;
				Material fontSharedMaterial = ((TMP_Text)label).fontSharedMaterial;
				Plugin.Logger.LogInfo((object)("[SharePermissions] GlyphDiag " + surface + ": text=\"" + ((TMP_Text)label).text + "\" font=" + (((Object)(object)font != (Object)null) ? ((Object)font).name : "<null>") + " assetMat=" + (((Object)(object)font != (Object)null && (Object)(object)((TMP_Asset)font).material != (Object)null) ? ((Object)((TMP_Asset)font).material).GetInstanceID().ToString() : "<null>") + " sharedMat=" + (((Object)(object)fontSharedMaterial != (Object)null) ? ((Object)fontSharedMaterial).GetInstanceID().ToString() : "<null>") + " " + $"chars={textInfo.characterCount} materialCount={textInfo.materialCount} overflow={((TMP_Text)label).overflowMode}"));
				Rect rect = ((TMP_Text)label).rectTransform.rect;
				Plugin.Logger.LogInfo((object)($"[SharePermissions] GlyphDiag geometry: rect={((Rect)(ref rect)).width:0.#}x{((Rect)(ref rect)).height:0.#} " + $"margin=({((TMP_Text)label).margin.x:0.#},{((TMP_Text)label).margin.y:0.#},{((TMP_Text)label).margin.z:0.#},{((TMP_Text)label).margin.w:0.#}) " + $"budget={((Rect)(ref rect)).height - ((TMP_Text)label).margin.y - ((TMP_Text)label).margin.w:0.#}"));
				if (textInfo.lineCount > 0 && textInfo.lineInfo != null && textInfo.lineInfo.Length != 0)
				{
					Plugin.Logger.LogInfo((object)($"[SharePermissions] GlyphDiag line0: lines={textInfo.lineCount} " + $"asc={textInfo.lineInfo[0].ascender:0.##} desc={textInfo.lineInfo[0].descender:0.##} " + $"height={textInfo.lineInfo[0].lineHeight:0.##}"));
				}
				float unionAsc = 0f;
				float unionDesc = 0f;
				List<TMP_FontAsset> seen = new List<TMP_FontAsset>();
				if ((Object)(object)font != (Object)null)
				{
					DescribeFace(font, ((TMP_Text)label).fontSize, seen, ref unionAsc, ref unionDesc);
				}
				for (int i = 0; i < textInfo.characterCount && i < textInfo.characterInfo.Length; i++)
				{
					TMP_FontAsset fontAsset = textInfo.characterInfo[i].fontAsset;
					if ((Object)(object)fontAsset != (Object)null)
					{
						DescribeFace(fontAsset, ((TMP_Text)label).fontSize, seen, ref unionAsc, ref unionDesc);
					}
				}
				Plugin.Logger.LogInfo((object)$"[SharePermissions] GlyphDiag union: box={unionAsc - unionDesc:0.##} (asc={unionAsc:0.##} desc={unionDesc:0.##})");
				for (int j = 0; j < textInfo.characterCount && j < textInfo.characterInfo.Length; j++)
				{
					char character = textInfo.characterInfo[j].character;
					if (character > '\u007f')
					{
						TMP_FontAsset fontAsset2 = textInfo.characterInfo[j].fontAsset;
						Plugin.Logger.LogInfo((object)(string.Format("[SharePermissions] GlyphDiag char U+{0:X4} -> asset={1} ", (int)character, ((Object)(object)fontAsset2 != (Object)null) ? ((Object)fontAsset2).name : "<null>") + $"matIdx={textInfo.characterInfo[j].materialReferenceIndex} visible={textInfo.characterInfo[j].isVisible} " + $"scale={textInfo.characterInfo[j].scale:0.####}"));
						break;
					}
				}
				int num = Math.Min(textInfo.characterCount, textInfo.characterInfo.Length);
				if (num > 0)
				{
					StringBuilder stringBuilder = new StringBuilder();
					for (int k = Math.Max(0, num - 2); k < num; k++)
					{
						stringBuilder.Append($"U+{(int)textInfo.characterInfo[k].character:X4} ");
					}
					bool flag = textInfo.characterInfo[num - 1].character == '\u0003';
					Plugin.Logger.LogInfo((object)$"[SharePermissions] GlyphDiag tail: {stringBuilder}truncated={flag}");
					if (flag)
					{
						Plugin.Logger.LogWarning((object)("[SharePermissions] GlyphDiag " + surface + ": layout TRUNCATED (trailing ETX) - an overflow path is live again; read the geometry/union lines above"));
					}
				}
				for (int l = 0; l < textInfo.materialCount && l < textInfo.meshInfo.Length; l++)
				{
					Material material = textInfo.meshInfo[l].material;
					Texture val = (((Object)(object)material != (Object)null && material.HasProperty(MainTexId)) ? material.GetTexture(MainTexId) : null);
					Plugin.Logger.LogInfo((object)($"[SharePermissions] GlyphDiag mesh[{l}]: verts={textInfo.meshInfo[l].vertexCount} " + "mat=" + (((Object)(object)material != (Object)null) ? ((Object)material).name : "<null>") + " tex=" + (((Object)(object)val != (Object)null) ? ((Object)val).name : "<null>")));
				}
				TMP_SubMeshUI[] componentsInChildren = ((Component)label).GetComponentsInChildren<TMP_SubMeshUI>(true);
				foreach (TMP_SubMeshUI val2 in componentsInChildren)
				{
					CanvasRenderer canvasRenderer = ((Graphic)val2).canvasRenderer;
					int num2 = 0;
					Vector3[] array = (((Object)(object)val2.mesh != (Object)null) ? val2.mesh.vertices : null);
					if (array != null)
					{
						Vector3[] array2 = array;
						foreach (Vector3 val3 in array2)
						{
							if (val3 != Vector3.zero)
							{
								num2++;
							}
						}
					}
					Plugin.Logger.LogInfo((object)($"[SharePermissions] GlyphDiag subobj \"{((Object)val2).name}\": active={((Component)val2).gameObject.activeInHierarchy} " + $"enabled={((Behaviour)val2).enabled} cull={canvasRenderer.cull} alpha={canvasRenderer.GetAlpha():0.##} matCount={canvasRenderer.materialCount} " + $"meshVerts={(((Object)(object)val2.mesh != (Object)null) ? val2.mesh.vertexCount : (-1))} liveVerts={num2}"));
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogInfo((object)("[SharePermissions] GlyphDiag failed: " + ex.Message));
			}
		}

		private static void DescribeFace(TMP_FontAsset fa, float fontSize, List<TMP_FontAsset> seen, ref float unionAsc, ref float unionDesc)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			FaceInfo faceInfo = fa.faceInfo;
			if (((FaceInfo)(ref faceInfo)).pointSize > 0)
			{
				float num = fontSize / (float)((FaceInfo)(ref faceInfo)).pointSize;
				unionAsc = Mathf.Max(unionAsc, ((FaceInfo)(ref faceInfo)).ascentLine * num);
				unionDesc = Mathf.Min(unionDesc, ((FaceInfo)(ref faceInfo)).descentLine * num);
				if (!seen.Contains(fa))
				{
					seen.Add(fa);
					Plugin.Logger.LogInfo((object)($"[SharePermissions] GlyphDiag face {FontAssetLabel(fa)}: pointSize={((FaceInfo)(ref faceInfo)).pointSize} " + $"asc={((FaceInfo)(ref faceInfo)).ascentLine:0.##} desc={((FaceInfo)(ref faceInfo)).descentLine:0.##} boxAt{fontSize:0.#}px={(((FaceInfo)(ref faceInfo)).ascentLine - ((FaceInfo)(ref faceInfo)).descentLine) * num:0.##}"));
				}
			}
		}

		private static string? ResolveInstalledPath(string[] paths, string wanted)
		{
			string text = wanted.Replace(" ", "");
			string text2 = null;
			foreach (string text3 in paths)
			{
				string text4 = Path.GetFileNameWithoutExtension(text3).Replace(" ", "");
				if (string.Equals(text4, text, StringComparison.OrdinalIgnoreCase))
				{
					return text3;
				}
				if (text2 == null && text4.IndexOf(text, StringComparison.OrdinalIgnoreCase) >= 0)
				{
					text2 = text3;
				}
			}
			return text2;
		}
	}
	internal sealed class PrivateChannelHud : MonoBehaviour
	{
		private sealed class Row
		{
			private readonly RectTransform rect;

			private readonly Image backing;

			private readonly TextMeshProUGUI label;

			private string lastName = "";

			private bool lastTalking;

			private bool lastDimmed;

			private float talkHoldUntil;

			private int actor = -1;

			private bool nameDirty;

			private Row(RectTransform rect, Image backing, TextMeshProUGUI label)
			{
				this.rect = rect;
				this.backing = backing;
				this.label = label;
			}

			internal static Row Build(RectTransform parent, int index)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0035: Expected O, but got Unknown
				//IL_0048: 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_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Expected O, but got Unknown
				//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c8: Expected O, but got Unknown
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
				//IL_011a: Unknown result type (might be due to invalid IL or missing references)
				//IL_013c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0143: Expected O, but got Unknown
				//IL_014a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Expected O, but got Unknown
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0168: Unknown result type (might be due to invalid IL or missing references)
				//IL_017e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				GameObject val = new GameObject($"Member{index}", new Type[1] { typeof(RectTransform) });
				RectTransform val2 = (RectTransform)val.transform;
				((Transform)val2).SetParent((Transform)(object)parent, false);
				val2.anchorMin = new Vector2(0f, 0.5f);
				val2.anchorMax = new Vector2(0f, 0.5f);
				val2.pivot = new Vector2(0f, 0.5f);
				val2.sizeDelta = new Vector2(240f, 28f);
				GameObject val3 = new GameObject("Backing", new Type[1] { typeof(RectTransform) });
				val3.transform.SetParent((Transform)(object)val2, false);
				RectTransform val4 = (RectTransform)val3.transform;
				val4.anchorMin = Vector2.zero;
				val4.anchorMax = Vector2.one;
				val4.offsetMin = Vector2.zero;
				val4.offsetMax = Vector2.zero;
				Image val5 = val3.AddComponent<Image>();
				((Graphic)val5).raycastTarget = false;
				((Graphic)val5).color = new Color(0f, 0f, 0f, 0.55f);
				GameObject val6 = new GameObject("Label", new Type[1] { typeof(RectTransform) });
				RectTransform val7 = (RectTransform)val6.transform;
				((Transform)val7).SetParent((Transform)(object)val2, false);
				val7.anchorMin = Vector2.zero;
				val7.anchorMax = Vector2.one;
				val7.offsetMin = new Vector2(8f, 0f);
				val7.offsetMax = new Vector2(-8f, 0f);
				TextMeshProUGUI val8 = val6.AddComponent<TextMeshProUGUI>();
				((TMP_Text)val8).fontSize = 18f;
				((Graphic)val8).color = ModStyle.ToastText;
				((TMP_Text)val8).alignment = (TextAlignmentOptions)4097;
				ModStyle.ConfigureSingleLineEllipsis(val8);
				((Graphic)val8).raycastTarget = false;
				((TMP_Text)val8).richText = true;
				Row result = new Row(val2, val5, val8);
				val.SetActive(false);
				return result;
			}

			internal void ApplyFont(TMP_FontAsset font)
			{
				((TMP_Text)label).font = font;
				((TMP_Text)label).ForceMeshUpdate(true, true);
			}

			internal void SetY(float y)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				rect.anchoredPosition = new Vector2(0f, y);
			}

			internal void Show(int actor, bool isSelf, float amplitude, bool dimmed)
			{
				//IL_006a: Unknown result type (might be due to invalid IL or missing references)
				if (!((Component)rect).gameObject.activeSelf)
				{
					((Component)rect).gameObject.SetActive(true);
				}
				if (actor != this.actor)
				{
					this.actor = actor;
					lastName = ResolveName(actor);
					nameDirty = true;
				}
				((Graphic)backing).color = new Color(0f, 0f, 0f, isSelf ? 0.8f : 0.55f);
				bool flag;
				if (amplitude > 0.005f)
				{
					flag = true;
					talkHoldUntil = Time.unscaledTime + 0.18f;
				}
				else
				{
					flag = Time.unscaledTime < talkHoldUntil;
				}
				if (nameDirty || flag != lastTalking || dimmed != lastDimmed)
				{
					nameDirty = false;
					lastTalking = flag;
					lastDimmed = dimmed;
					string text = (dimmed ? ("<color=#6f7d88>" + lastName + "</color>") : lastName);
					((TMP_Text)label).text = (flag ? (text + "  <color=#d9e8a8>●</color>") : text);
					if (diagRow == null && OverlayFont.WantsGlyphDiagnostic(lastName, "hud"))
					{
						diagRow = this;
						diagFrame = Time.frameCount + 2;
					}
				}
			}

			internal void LogGlyphDiagnostic()
			{
				OverlayFont.LogGlyphDiagnostic(label, "hud");
			}

			internal void Hide()
			{
				if (((Component)rect).gameObject.activeSelf)
				{
					((Component)rect).gameObject.SetActive(false);
				}
				actor = -1;
				lastName = "";
				lastTalking = false;
				lastDimmed = false;
				talkHoldUntil = 0f;
			}
		}

		private static PrivateChannelHud? instance;

		private RectTransform panel;

		private TextMeshProUGUI title;

		private readonly Row[] rows = new Row[8];

		private int fontGeneration = -1;

		private static Row? diagRow;

		private static int diagFrame;

		private bool lastTitleMicMuted;

		private bool lastTitleMuted;

		private readonly int[] orderBuf = new int[8];

		internal static void Init()
		{
			//IL_0013: 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_0021: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)instance != (Object)null))
			{
				GameObject val = new GameObject("SharePermissionsPrivateHud")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)(object)val);
				Canvas val2 = val.AddComponent<Canvas>();
				val2.renderMode = (RenderMode)0;
				val2.sortingOrder = 90;
				CanvasScaler val3 = val.AddComponent<CanvasScaler>();
				val3.uiScaleMode = (ScaleMode)1;
				val3.referenceResolution = new Vector2(1920f, 1080f);
				val3.matchWidthOrHeight = 1f;
				OverlayFont.RegisterOwnRoot(val.transform);
				instance = val.AddComponent<PrivateChannelHud>();
				instance.BuildTree(val.transform);
			}
		}

		private void BuildTree(Transform canvasRoot)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Panel", new Type[1] { typeof(RectTransform) });
			panel = (RectTransform)val.transform;
			((Transform)panel).SetParent(canvasRoot, false);
			panel.sizeDelta = new Vector2(240f, 26f);
			title = MakeLabel(panel, "Private voice", 26f, bold: true);
			for (int i = 0; i < rows.Length; i++)
			{
				rows[i] = Row.Build(panel, i);
			}
			val.SetActive(false);
		}

		private void Update()
		{
			OverlayFont.Pump();
			if (OverlayFont.Generation != fontGeneration)
			{
				fontGeneration = OverlayFont.Generation;
				TMP_FontAsset font = OverlayFont.Font;
				if ((Object)(object)font != (Object)null)
				{
					ApplyFont(title, font);
					Row[] array = rows;
					foreach (Row row in array)
					{
						row.ApplyFont(font);
					}
				}
			}
			bool flag = ModConfig.ShowPrivateChannelHud.Value && PrivateVoiceChannel.LocalActive;
			if (((Component)panel).gameObject.activeSelf != flag)
			{
				((Component)panel).gameObject.SetActive(flag);
			}
			if (flag)
			{
				Reposition();
				SyncTitle();
				SyncRoster();
				if (diagRow != null && Time.frameCount >= diagFrame)
				{
					Row row2 = diagRow;
					diagRow = null;
					row2.LogGlyphDiagnostic();
				}
			}
		}

		private void Reposition()
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			HudPlacement hudPlacement = HudLayout.For(ModConfig.PrivateChannelHudCorner.Value);
			RectTransform obj = panel;
			RectTransform obj2 = panel;
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(hudPlacement.AnchorX, hudPlacement.AnchorY);
			obj2.anchorMax = val;
			obj.anchorMin = val;
			panel.pivot = new Vector2(hudPlacement.PivotX, hudPlacement.PivotY);
			panel.anchoredPosition = new Vector2(hudPlacement.InsetX, hudPlacement.InsetY);
			float num = ((hudPlacement.GrowSign < 0f) ? (-13f) : 13f);
			((TMP_Text)title).rectTransform.anchoredPosition = new Vector2(0f, num);
			float num2 = num + hudPlacement.GrowSign * 26f;
			for (int i = 0; i < rows.Length; i++)
			{
				rows[i].SetY(num2 + hudPlacement.GrowSign * (float)i * 30f);
			}
		}

		private void SyncTitle()
		{
			bool micMuted = PrivateVoiceLocalPrefs.MicMuted;
			bool muted = PrivateVoiceLocalPrefs.Muted;
			if (micMuted != lastTitleMicMuted || muted != lastTitleMuted)
			{
				lastTitleMicMuted = micMuted;
				lastTitleMuted = muted;
				string text = (micMuted ? ((!muted) ? "MIC OFF" : "MIC+SND OFF") : ((!muted) ? "" : "SND OFF"));
				string text2 = text;
				((TMP_Text)title).text = ((text2.Length == 0) ? "Private voice" : ("Private voice  <size=75%><color=#ef5350>" + text2 + "</color></size>"));
			}
		}

		private void SyncRoster()
		{
			int[] array = PrivateVoiceChannel.MemberActors();
			int num = ((PhotonNetwork.InRoom && PhotonNetwork.LocalPlayer != null) ? PhotonNetwork.LocalPlayer.ActorNumber : (-1));
			if (array.Length > rows.Length && Time.frameCount % 300 == 0)
			{
				Plugin.Logger.LogWarning((object)$"[SharePermissions] Private HUD: {array.Length} members exceeds {rows.Length} rows; showing first {rows.Length}");
			}
			int num2 = ScratchOrder(array, num);
			for (int i = 0; i < rows.Length; i++)
			{
				if (i >= num2)
				{
					rows[i].Hide();
					continue;
				}
				int num3 = orderBuf[i];
				bool flag = num3 == num;
				float amplitude = (flag ? LocalAmplitude() : PrivateSpeakers.AmplitudeFor(num3));
				rows[i].Show(num3, flag, amplitude, flag && PrivateVoiceLocalPrefs.MicMuted);
			}
		}

		private int ScratchOrder(int[] members, int localActor)
		{
			int num = orderBuf.Length;
			bool flag = localActor > 0 && Array.IndexOf(members, localActor) >= 0;
			int num2 = 0;
			if (flag)
			{
				orderBuf[num2++] = localActor;
			}
			for (int i = 0; i < members.Length; i++)
			{
				if (num2 >= num)
				{
					break;
				}
				if (members[i] != localActor)
				{
					orderBuf[num2++] = members[i];
				}
			}
			int num3 = (flag ? 1 : 0);
			if (num2 - num3 > 1)
			{
				Array.Sort(orderBuf, num3, num2 - num3);
			}
			return num2;
		}

		private static float LocalAmplitude()
		{
			Recorder val = PrivateVoiceClient.Instance?.PrivateRecorder;
			if (!((Object)(object)val != (Object)null) || !val.TransmitEnabled)
			{
				return 0f;
			}
			return MicTee.Level;
		}

		private static string ResolveName(int actor)
		{
			Room currentRoom = PhotonNetwork.CurrentRoom;
			Player val = ((currentRoom != null) ? currentRoom.GetPlayer(actor, false) : null);
			if (val == null)
			{
				return $"Player_{actor}";
			}
			return MenuUiHelpers.SanitizePlayerName(val.NickName, $"Player_{actor}");
		}

		private static TextMeshProUGUI MakeLabel(RectTransform parent, string text, float height, bool bold)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_0047: 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)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(bold ? "Title" : "Label", new Type[1] { typeof(RectTransform) });
			RectTransform val2 = (RectTransform)val.transform;
			((Transform)val2).SetParent((Transform)(object)parent, false);
			val2.anchorMin = new Vector2(0f, 0.5f);
			val2.anchorMax = new Vector2(1f, 0.5f);
			val2.pivot = new Vector2(0.5f, 0.5f);
			val2.sizeDelta = new Vector2(0f, height);
			TextMeshProUGUI val3 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val3).fontSize = 18f;
			((Graphic)val3).color = ModStyle.ToastText;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)4097;
			ModStyle.ConfigureSingleLineEllipsis(val3);
			((Graphic)val3).raycastTarget = false;
			((TMP_Text)val3).richText = true;
			if (bold)
			{
				((TMP_Text)val3).fontStyle = (FontStyles)1;
			}
			((TMP_Text)val3).text = text;
			return val3;
		}

		private static void ApplyFont(TextMeshProUGUI label, TMP_FontAsset font)
		{
			((TMP_Text)label).font = font;
			((TMP_Text)label).ForceMeshUpdate(true, true);
		}
	}
	internal sealed class SettingsPanelController
	{
		private const int RateMin = 1;

		private const int RateMax = 300;

		private const int KickRateMin = 350;

		private const int KickRateMax = 1000;

		private const int SizeKbMin = 1;

		private const int SizeKbMax = 256;

		private const int BytesPerKb = 1024;

		private const int CountdownMin = 0;

		private const int CountdownMax = 60;

		private const int HistoryCountMin = 10;

		private const int HistoryCountMax = 500;

		private static readonly Color ClearHeaderColor = ModStyle.ConfirmDestructive;

		private readonly REPOPopupPage page;

		private readonly List<REPOScrollViewElement> elems = new List<REPOScrollViewElement>();

		private bool tabVisible = true;

		private bool initializing;

		private REPOToggle? masterToggle;

		private REPOToggle? logOnlyToggle;

		private REPOScrollViewElement? logOnlyElem;

		internal SettingsPanelController(REPOPopupPage page)
		{
			this.page = page;
		}

		internal void Build()
		{
			if (!SemiFunc.IsMasterClient())
			{
				BuildReadOnly();
				return;
			}
			initializing = true;
			FloodMode value = ModConfig.Mode.Value;
			AddLabel("<size=115%>Flood protection</size>  <size=75%><color=#ffb454>(Experimental)</color></size>");
			masterToggle = AddToggle("Flood protection", value != FloodMode.Off, OnMasterToggled, out REPOScrollViewElement _);
			logOnlyToggle = AddToggle("Log only (don't kick)", value == FloodMode.LogOnly, OnLogOnlyToggled, out logOnlyElem);
			AddSlider("Drop RPCs over", "", 1, 300, Mathf.Clamp(ModConfig.RpcFloodPerSecond.Value, 1, 300), "/s", OnRateChanged);
			AddLabel("<size=75%><color=#6f7d88>Per-player incoming RPCs/second above which packets are dropped locally. This alone never kicks anyone.</color></size>");
			AddSlider("Auto-kick over", "", 350, 1000, Mathf.Clamp(ModConfig.AutoKickRpcPerSecond.Value, 350, 1000), "/s", OnKickRateChanged);
			AddLabel("<size=75%><color=#6f7d88>Per-player RPCs/second that actually gets a flooder kicked. Kept above the drop rate so the burst every client sends on a lobby join can't kick an innocent player.</color></size>");
			AddSlider("Max RPC size", "", 1, 256, Mathf.Clamp(ModConfig.RpcMaxBytes.Value / 1024, 1, 256), " KB", OnSizeChanged);
			AddLabel("<size=75%><color=#6f7d88>Largest single incoming RPC.</color></size>");
			AddLabel("<size=75%><color=#6f7d88>Runs in the lobby only.</color></size>");
			AddLabel("<size=115%>Lobby</size>");
			AddSlider("Start countdown", "", 0, 60, Mathf.Clamp(ModConfig.StartCountdownSeconds.Value, 0, 60), " s", OnCountdownSecondsChanged);
			AddLabel("<size=75%><color=#6f7d88>Everyone sees the countdown; you and moderators can cancel it. At 0 the run starts instantly and the game's own start prompt applies instead.</color></size>");
			BuildLobbyConfirmRow();
			BuildAdminMenuSection(hostBuild: true);
			BuildInterfaceSection();
			BuildNameColorsSection();
			BuildHistorySection(includeClearButton: true);
			BuildNotificationsSection();
			initializing = false;
			ApplyLogOnlyVisibility(value != FloodMode.Off);
		}

		private void BuildReadOnly()
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			initializing = true;
			FloodMode value = ModConfig.Mode.Value;
			AddLabel("<size=115%>Flood protection</size>  <size=75%><color=#ffb454>(Experimental)</color></size>");
			AddLabel("<size=75%><color=#6f7d88>View only - the host's flood protection settings govern the room.</color></size>");
			AddValue("Flood protection", OnOff(value != FloodMode.Off));
			if (value != FloodMode.Off)
			{
				AddValue("Log only (don't kick)", OnOff(value == FloodMode.LogOnly));
			}
			AddValue("Drop RPCs over", $"{ModConfig.RpcFloodPerSecond.Value}/s");
			AddValue("Auto-kick over", $"{ModConfig.AutoKickRpcPerSecond.Value}/s");
			AddValue("Max RPC size", $"{ModConfig.RpcMaxBytes.Value / 1024} KB");
			AddLabel("<size=75%><color=#6f7d88>Runs in the lobby only.</color></size>");
			AddLabel("<size=115%>Lobby</size>");
			AddLabel("<size=75%><color=#6f7d88>The host's countdown length applies.</color></size>");
			BuildLobbyConfirmRow();
			BuildAdminMenuSection(hostBuild: false);
			BuildInterfaceSection();
			AddLabel("<size=115%>Name colors</size>");
			if (NameColors.Advertised)
			{
				AddColorValue("Host", NameColors.HostColor);
				AddColorValue("Moderator", NameColors.ModeratorColor);
				AddLabel("<size=75%><color=#6f7d88>Set by the host.</color></size>");
			}
			else
			{
				AddLabel("<size=75%><color=#6f7d88>Not set by this host.</color></size>");
			}
			BuildHistorySection(includeClearButton: false);
			BuildNotificationsSection();
			initializing = false;
		}

		private void AddValue(string name, string value)
		{
			AddLabel("<color=#8a94a0>" + name + "</color>  <color=#e6eaee>" + value + "</color>");
		}

		private void AddColorValue(string name, Color color)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			string text = NameColors.ToHex(color);
			AddLabel("<color=#8a94a0>" + name + "</color>  <color=#" + text + ">#" + text + "</color>");
		}

		private static string OnOff(bool on)
		{
			if (!on)
			{
				return "Off";
			}
			return "On";
		}

		private void BuildNameColorsSection()
		{
			AddLabel("<size=115%>Name colors</size>");
			AddColorRow("Host", "Color for the host's name.", () => NameColors.HostColor, NameColors.SetHostColor);
			AddColorRow("Moderator", "Color for moderators' names.", () => NameColors.ModeratorColor, NameColors.SetModeratorColor);
			AddLabel("<size=75%><color=#6f7d88>Applies for everyone running the mod: the lobby list, the name above their head in-game, and the escape menu's volume rows. Set one player's own color from the Members tab.</color></size>");
		}

		private void AddColorRow(string caption, string description, Func<Color> read, Action<Color> write)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			REPOButton row = null;
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: 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)
				row = MenuAPI.CreateREPOButton("", (Action)delegate
				{
					//IL_001c: Unknown result type (might be due to invalid IL or missing references)
					ColorPickerPage.Open(caption + " name color", description, read(), delegate(Color picked)
					{
						//IL_0006: 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)
						write(picked);
						NameColorSync.Broadcast();
						Relabel(row, caption, read());
					});
				}, sv, default(Vector2));
				((TMP_Text)row.labelTMP).richText = true;
				((TMP_Text)row.labelTMP).fontSize = 14f;
				row.overrideButtonSize = new Vector2(250f, 24f);
				Relabel(row, caption, read());
				return ((REPOElement)row).rectTransform;
			}, 0f, 2f);
			Track((REPOElement?)(object)row);
		}

		private static void Relabel(REPOButton? row, string caption, Color color)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)row == (Object)null))
			{
				string text = NameColors.ToHex(color);
				((TMP_Text)row.labelTMP).text = caption + "  <color=#" + text + ">#" + text + "</color>";
			}
		}

		private void BuildInterfaceSection()
		{
			AddLabel("<size=115%>Interface</size>");
			AddToggle("Head markers", ModConfig.ShowHeadMarkers.Value, delegate(bool v)
			{
				if (!initializing)
				{
					ModConfig.ShowHeadMarkers.Value = v;
				}
			}, out REPOScrollViewElement elem);
			AddToggle("Name colors", ModConfig.ShowModeratorNameColor.Value, delegate(bool v)
			{
				if (!initializing)
				{
					ModConfig.ShowModeratorNameColor.Value = v;
				}
			}, out elem);
			AddToggle("Ghost lobby rows", ModConfig.ShowGhostRows.Value, delegate(bool v)
			{
				if (!initializing)
				{
					ModConfig.ShowGhostRows.Value = v;
				}
			}, out elem);
			AddToggle("Members talk dot", ModConfig.ShowTalkDots.Value, delegate(bool v)
			{
				if (!initializing)
				{
					ModConfig.ShowTalkDots.Value = v;
				}
			}, out elem);
			AddToggle("Private channel HUD", ModConfig.ShowPrivateChannelHud.Value, delegate(bool v)
			{
				if (!initializing)
				{
					ModConfig.ShowPrivateChannelHud.Value = v;
				}
			}, out elem);
			AddCornerCycle();
		}

		private void BuildHistorySection(bool includeClearButton)
		{
			AddLabel("<size=115%>History</size>");
			AddToggle("Keep history across sessions", ModConfig.PersistHistory.Value, delegate(bool v)
			{
				if (!initializing)
				{
					ModConfig.PersistHistory.Value = v;
				}
			}, out REPOScrollViewElement elem);
			AddToggle("Write forensic log", ModConfig.WriteForensicLog.Value, delegate(bool v)
			{
				if (!initializing)
				{
					ModConfig.WriteForensicLog.Value = v;
				}
			}, out elem);
			AddSlider("Past events to load", "", 10, 500, Mathf.Clamp(ModConfig.PersistedHistoryCount.Value, 10, 500), "", OnHistoryCountChanged);
			AddLabel("<size=75%><color=#6f7d88>The forensic log is a plain-text trail on disk, kept when you clear history. Turning it off stops new lines; the existing file is left alone.</color></size>");
			if (includeClearButton)
			{
				AddButton("<color=#ef5350>Clear history</color>", ConfirmClearHistory);
			}
		}

		internal void SetTabVisible(bool visible)
		{
			tabVisible = visible;
			foreach (REPOScrollViewElement elem in elems)
			{
				if ((Object)(object)elem != (Object)null)
				{
					elem.visibility = visible;
				}
			}
			if (visible)
			{
				ApplyLogOnlyVisibility((Object)(object)masterToggle != (Object)null && masterToggle.state);
			}
		}

		private void ApplyLogOnlyVisibility(bool protectionOn)
		{
			if ((Object)(object)logOnlyElem != (Object)null)
			{
				logOnlyElem.visibility = tabVisible && protectionOn;
			}
		}

		private void OnMasterToggled(bool on)
		{
			if (!initializing)
			{
				ModConfig.Mode.Value = (on ? (((Object)(object)logOnlyToggle != (Object)null && logOnlyToggle.state) ? FloodMode.LogOnly : FloodMode.Kick) : FloodMode.Off);
				ApplyLogOnlyVisibility(on);
			}
		}

		private void OnLogOnlyToggled(bool logOnly)
		{
			if (!initializing && !((Object)(object)masterToggle == (Object)null) && masterToggle.state)
			{
				ModConfig.Mode.Value = (logOnly ? FloodMode.LogOnly : FloodMode.Kick);
			}
		}

		private void OnRateChanged(int value)
		{
			if (!initializing)
			{
				ModConfig.RpcFloodPerSecond.Value = value;
			}
		}

		private void OnKickRateChanged(int value)
		{
			if (!initializing)
			{
				ModConfig.AutoKickRpcPerSecond.Value = value;
			}
		}

		private void OnSizeChanged(int kilobytes)
		{
			if (!initializing)
			{
				ModConfig.RpcMaxBytes.Value = kilobytes * 1024;
			}
		}

		private void OnHistoryCountChanged(int value)
		{
			if (!initializing)
			{
				ModConfig.PersistedHistoryCount.Value = value;
			}
		}

		private void OnCountdownSecondsChanged(int value)
		{
			if (!initializing)
			{
				ModConfig.StartCountdownSeconds.Value = value;
			}
		}

		private void BuildAdminMenuSection(bool hostBuild)
		{
			AddLabel("<size=115%>Admin menu</size>");
			if (hostBuild)
			{
				AddToggle("Grant to moderators", ModConfig.GrantAdminMenu.Value, delegate(bool v)
				{
					if (!initializing)
					{
						ModConfig.GrantAdminMenu.Value = v;
					}
				}, out REPOScrollViewElement _);
				AddLabel(AdminMenuBridge.IsAvailable ? "<size=75%><color=#6f7d88>Lets your moderators open the R.E.P.O. Admin Menu. They need it installed too - it is a local menu. Turning this off re-locks it for everyone immediately.</color></size>" : "<size=75%><color=#6f7d88>The R.E.P.O. Admin Menu is not installed on this device, so nothing is granted. Install it to use this.</color></size>");
			}
			else
			{
				AddValue("Granted by host", OnOff(HostCapabilities.AdminMenu));
				AddLabel(HostCapabilities.AdminMenu ? "<size=75%><color=#6f7d88>You may open the R.E.P.O. Admin Menu if you have it installed.</color></size>" : "<size=75%><color=#6f7d88>The host either does not run the R.E.P.O. Admin Menu or does not grant it.</color></size>");
			}
		}

		private void BuildLobbyConfirmRow()
		{
			AddToggle("Confirm back to lobby", ModConfig.ConfirmBackToLobby.Value, delegate(bool v)
			{
				if (!initializing)
				{
					ModConfig.ConfirmBackToLobby.Value = v;
				}
			}, out REPOScrollViewElement _);
		}

		private void BuildNotificationsSection()
		{
			AddLabel("<size=115%>Notifications</size>");
			AddToggle("Notifications", ModConfig.ShowNotifications.Value, delegate(bool v)
			{
				if (!initializing)
				{
					ModConfig.ShowNotifications.Value = v;
				}
			}, out REPOScrollViewElement _);
			AddSlider("Time on screen", "", 2, 10, Mathf.Clamp(ModConfig.NotificationSeconds.Value, 2, 10), " s", OnNotifySecondsChanged);
			AddLabel("<size=75%><color=#6f7d88>Moderation events and your own role changes, shown to you only. Applies on this device.</color></size>");
		}

		private void OnNotifySecondsChanged(int value)
		{
			if (!initializing)
			{
				ModConfig.NotificationSeconds.Value = value;
			}
		}

		private void ConfirmClearHistory()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			MenuUiHelpers.ShowTwoOptionPopup("Clear history", ClearHeaderColor, "Delete all persisted moderation history?\nThe forensic sharepermissions.log file is kept.", delegate
			{
				AuditLog.Clear();
				AuditStore.ClearAll();
				MenuUiHelpers.ClosePage(page);
			}, null, "Delete", "Keep");
		}

		private void AddLabel(string richText)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			REPOLabel made = null;
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0009: 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)
				REPOLabel val = MenuAPI.CreateREPOLabel(richText, sv, default(Vector2));
				((TMP_Text)val.labelTMP).richText = true;
				((TMP_Text)val.labelTMP).fontSize = 14f;
				MenuUiHelpers.SizeWrappedLabel(val, richText, 250f);
				made = val;
				return ((REPOElement)val).rectTransform;
			}, 0f, 6f);
			Track((REPOElement?)(object)made);
		}

		private REPOToggle? AddToggle(string text, bool defaultOn, Action<bool> onToggle, out REPOScrollViewElement? elem)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected O, but got Unknown
			REPOToggle made = null;
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0016: Unknown result type (might be due to invalid IL or missing references)
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				string text2 = text;
				Action<bool> action = onToggle;
				bool flag = defaultOn;
				REPOToggle val = MenuAPI.CreateREPOToggle(text2, action, sv, default(Vector2), "ON", "OFF", flag);
				((TMP_Text)val.labelTMP).fontSize = 14f;
				made = val;
				return ((REPOElement)val).rectTransform;
			}, 0f, 2f);
			elem = Track((REPOElement?)(object)made);
			return made;
		}

		private void AddSlider(string text, string description, int min, int max, int defaultValue, string postfix, Action<int> onChanged)
		{
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			REPOSlider made = null;
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0032: 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)
				string text2 = text;
				string text3 = description;
				Action<int> action = onChanged;
				int num = min;
				int num2 = max;
				int num3 = defaultValue;
				string text4 = postfix;
				return ((REPOElement)(made = MenuAPI.CreateREPOSlider(text2, text3, action, sv, default(Vector2), num, num2, num3, "", text4, (BarBehavior)0))).rectTransform;
			}, 0f, 2f);
			Track((REPOElement?)(object)made);
		}

		private void AddButton(string richText, Action onClick)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			REPOButton made = null;
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0015: 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)
				REPOButton val = MenuAPI.CreateREPOButton(richText, onClick, sv, default(Vector2));
				((TMP_Text)val.labelTMP).richText = true;
				((TMP_Text)val.labelTMP).fontSize = 14f;
				val.overrideButtonSize = new Vector2(250f, 24f);
				made = val;
				return ((REPOElement)val).rectTransform;
			}, 0f, 2f);
			Track((REPOElement?)(object)made);
		}

		private void AddCornerCycle()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			REPOButton made = null;
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_006f: Unknown result type (might be due to invalid IL or missing references)
				made = MenuAPI.CreateREPOButton(Caption(), (Action)delegate
				{
					if (!initializing && !((Object)(object)made == (Object)null))
					{
						HudCorner value = ModConfig.PrivateChannelHudCorner.Value switch
						{
							HudCorner.TopRight => HudCorner.BottomRight, 
							HudCorner.BottomRight => HudCorner.BottomLeft, 
							HudCorner.BottomLeft => HudCorner.TopLeft, 
							_ => HudCorner.TopRight, 
						};
						ModConfig.PrivateChannelHudCorner.Value = value;
						((TMP_Text)made.labelTMP).text = Caption();
					}
				}, sv, default(Vector2));
				((TMP_Text)made.labelTMP).richText = true;
				((TMP_Text)made.labelTMP).fontSize = 14f;
				made.overrideButtonSize = new Vector2(250f, 24f);
				return ((REPOElement)made).rectTransform;
			}, 0f, 2f);
			Track((REPOElement?)(object)made);
			static string Caption()
			{
				return $"HUD corner: {ModConfig.PrivateChannelHudCorner.Value}";
			}
		}

		private REPOScrollViewElement? Track(REPOElement? made)
		{
			if ((Object)(object)made == (Object)null)
			{
				return null;
			}
			REPOScrollViewElement component = ((Component)made).GetComponent<REPOScrollViewElement>();
			if ((Object)(object)component != (Object)null)
			{
				elems.Add(component);
			}
			return component;
		}
	}
	internal sealed class StartCountdownDisplay : MonoBehaviour
	{
		private GameObject? root;

		private CanvasGroup? fade;

		private TMP_Text? label;

		private bool richAccent;

		private GameObject? nativeStart;

		private int lastShown = -2;

		private Component? nativeButton;

		private bool nativeBroken;

		private bool swapped;

		private string savedText = "";

		private Color savedColor;

		private int lastNativeShown = -2;

		private bool lastHover;

		private string lastNativeText = "";

		internal void Wire(GameObject root, CanvasGroup? fade, TMP_Text label, bool richAccent, GameObject? nativeStart)
		{
			this.root = root;
			this.fade = fade;
			this.label = label;
			this.richAccent = richAccent;
			this.nativeStart = nativeStart;
			lastShown = -2;
		}

		private void Update()
		{
			if ((Object)(object)root == (Object)null || (Object)(object)label == (Object)null)
			{
				return;
			}
			bool active = StartCountdown.Active;
			bool flag = false;
			if ((Object)(object)nativeStart != (Object)null && !nativeBroken)
			{
				try
				{
					flag = DriveNativeButton(active);
				}
				catch
				{
					nativeBroken = true;
				}
			}
			bool flag2 = active && !flag;
			if (root.activeSelf != flag2)
			{
				root.SetActive(flag2);
				if (flag2 && (Object)(object)fade != (Object)null)
				{
					fade.alpha = 0f;
				}
				if (!flag2)
				{
					lastShown = -2;
				}
			}
			if (flag2)
			{
				if ((Object)(object)fade != (Object)null)
				{
					fade.alpha = Mathf.Lerp(fade.alpha, 1f, Time.deltaTime * 10f);
				}
				int remainingSeconds = StartCountdown.RemainingSeconds;
				if (remainingSeconds != lastShown)
				{
					lastShown = remainingSeconds;
					string text = CountdownText(remainingSeconds);
					label.text = (richAccent ? ("<color=#ff8500>" + text + "</color>") : text);
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private bool DriveNativeButton(bool active)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			Component? obj = nativeButton;
			MenuButton val = (MenuButton)(object)((obj is MenuButton) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				val = nativeStart.GetComponent<MenuButton>();
				if ((Object)(object)val == (Object)null)
				{
					nativeBroken = true;
					return false;
				}
				nativeButton = (Component?)(object)val;
			}
			if ((Object)(object)val.buttonText == (Object)null)
			{
				return false;
			}
			if (!active || !ModerationActions.LocalCanModerate || !((Component)val).gameObject.activeInHierarchy)
			{
				if (swapped)
				{
					((TMP_Text)val.buttonText).text = savedText;
					val.colorNormal = savedColor;
					swapped = false;
				}
				return false;
			}
			if (!swapped)
			{
				savedText = ((TMP_Text)val.buttonText).text;
				savedColor = val.colorNormal;
				swapped = true;
				lastNativeShown = -2;
			}
			val.colorNormal = ModStyle.NativeAccent;
			int remainingSeconds = StartCountdown.RemainingSeconds;
			bool hovering = val.hovering;
			if (remainingSeconds != lastNativeShown || hovering != lastHover || ((TMP_Text)val.buttonText).text != lastNativeText)
			{
				lastNativeShown = remainingSeconds;
				lastHover = hovering;
				lastNativeText = (hovering ? "Cancel" : CountdownText(remainingSeconds));
				((TMP_Text)val.buttonText).text = lastNativeText;
			}
			return true;
		}

		private static string CountdownText(int n)
		{
			if (n <= 0)
			{
				return "Starting…";
			}
			return $"Starts in {n}";
		}
	}
	internal sealed class StartCountdownDriver : MonoBehaviour
	{
		private static StartCountdownDriver? instance;

		internal static void Init()
		{
			//IL_0013: 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_0021: Expected O, but got Unknown
			if (!((Object)(object)instance != (Object)null))
			{
				GameObject val = new GameObject("StartCountdownDriver")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)(object)val);
				instance = val.AddComponent<StartCountdownDriver>();
			}
		}

		private void Update()
		{
			StartCountdown.Tick();
		}

		private void OnDestroy()
		{
			if ((Object)(object)instance == (Object)(object)this)
			{
				instance = null;
			}
		}
	}
	internal static class TabBandLayout
	{
		internal const float PlusTabWidth = 26f;

		internal static float ColumnCenterIn(int index, int columns, float left, float right)
		{
			return left + ((float)index + 0.5f) * (right - left) / (float)columns;
		}

		internal static float TextBandRight(float bandRight)
		{
			return bandRight - 26f;
		}

		internal static float TextColumnWidth(int columns, float left, float right)
		{
			return (TextBandRight(right) - left) / (float)columns;
		}

		internal static float TextTabCenter(int index, int columns, float left, float right)
		{
			return ColumnCenterIn(index, columns, left, TextBandRight(right));
		}

		internal static float PlusTabCenter(float bandRight)
		{
			return bandRight - 13f;
		}
	}
	internal sealed class TokensPanelController
	{
		private const int RowHeadroom = 8;

		private const int NameTrim = 16;

		private const int TokenPrefix = 12;

		private static readonly Color ConfirmHeaderColor = ModStyle.ConfirmDanger;

		private readonly REPOPopupPage page;

		private readonly List<REPOScrollViewElement> staticElems = new List<REPOScrollViewElement>();

		private readonly HashSet<string> presentSteamIds = new HashSet<string>();

		private bool tabVisible = true;

		private bool builtAsHost;

		private List<IssuedToken> issued = new List<IssuedToken>();

		private List<HeldToken> held = new List<HeldToken>();

		private REPOButton?[] issuedRows = Array.Empty<REPOButton>();

		private REPOScrollViewElement?[] issuedElems = Array.Empty<REPOScrollViewElement>();

		private REPOScrollViewElement? issuedEmptyElem;

		private REPOButton?[] heldRows = Array.Empty<REPOButton>();

		private REPOScrollViewElement?[] heldElems = Array.Empty<REPOScrollViewElement>();

		private REPOScrollViewElement? heldEmptyElem;

		private REPOLabel? issuedHeader;

		private REPOScrollViewElement? issuedHeaderElem;

		private REPOLabel? heldHeader;

		private REPOScrollViewElement? heldHeaderElem;

		private REPOScrollViewElement? legacyHintElem;

		private REPOLabel? issuedStatus;

		private REPOScrollViewElement? issuedStatusElem;

		private string issuedStatusText = "";

		private REPOLabel? heldStatus;

		private REPOScrollViewElement? heldStatusElem;

		private string heldStatusText = "";

		internal Action? CountChanged;

		private int lastReportedCount = -1;

		internal int TabCount { get; private set; }

		internal TokensPanelController(REPOPopupPage page)
		{
			this.page = page;
		}

		internal void Build()
		{
			builtAsHost = SemiFunc.IsMasterClient();
			(REPOButton[], REPOScrollViewElement[]) tuple;
			if (builtAsHost)
			{
				issuedHeader = MakeLabel("<size=115%>Moderators you've promoted</size>");
				issuedHeaderElem = ElemOf(issuedHeader);
				AddStaticLabel(Hint("Click a row to take access back, online or not."));
				issued = PromotedTokenStore.Entries();
				tuple = BuildRowPool(issued.Count + 8, OnIssuedClicked);
				issuedRows = tuple.Item1;
				issuedElems = tuple.Item2;
				issuedEmptyElem = ElemOf(MakeLabel("<color=#6f7d88>No access given yet. Promote a player from the Members tab.</color>"));
				legacyHintElem = ElemOf(MakeLabel(Hint("Unnamed rows came from an older version.")));
				issuedStatus = MakeLabel("");
				issuedStatusElem = ElemOf(issuedStatus);
			}
			heldHeader = MakeLabel("<size=115%>Hosts who gave you access</size>");
			heldHeaderElem = ElemOf(heldHeader);
			AddStaticLabel(Hint("Offered when you join their lobby."));
			held = ClientTokenStore.Entries();
			tuple = BuildRowPool(held.Count + 8, OnHeldClicked);
			heldRows = tuple.Item1;
			heldElems = tuple.Item2;
			heldEmptyElem = ElemOf(MakeLabel("<color=#6f7d88>No access yet. A host gives you access when they promote you.</color>"));
			heldStatus = MakeLabel("");
			heldStatusElem = ElemOf(heldStatus);
			Refresh();
		}

		internal void SetTabVisible(bool visible)
		{
			tabVisible = visible;
			foreach (REPOScrollViewElement staticElem in staticElems)
			{
				if ((Object)(object)staticElem != (Object)null)
				{
					staticElem.visibility = visible;
				}
			}
			if (visible)
			{
				SetIssuedStatus("");
				SetHeldStatus("");
			}
			Refresh();
		}

		private void Refresh()
		{
			RebuildPresence();
			string hostSteamId = CurrentHostSteamId();
			if (builtAsHost)
			{
				issued = (from t in PromotedTokenStore.Entries()
					orderby t.SteamId.Length > 0 && presentSteamIds.Contains(t.SteamId) descending
					select t).ToList();
				if (issued.Count > issuedRows.Length)
				{
					Plugin.Logger.LogWarning((object)$"Access tab: {issued.Count} issued grants exceed {issuedRows.Length} rows; reopen the panel to see all");
				}
				for (int num = 0; num < issuedRows.Length; num++)
				{
					bool flag = num < issued.Count;
					if ((Object)(object)issuedElems[num] != (Object)null)
					{
						issuedElems[num].visibility = tabVisible && flag;
					}
					if (flag && (Object)(object)issuedRows[num] != (Object)null)
					{
						((TMP_Text)issuedRows[num].labelTMP).text = IssuedCaption(issued[num]);
					}
				}
				if ((Object)(object)issuedEmptyElem != (Object)null)
				{
					issuedEmptyElem.visibility = tabVisible && issued.Count == 0;
				}
				if ((Object)(object)legacyHintElem != (Object)null)
				{
					legacyHintElem.visibility = tabVisible && issued.Any((IssuedToken t) => t.Name.Length == 0);
				}
				if ((Object)(object)issuedStatusElem != (Object)null)
				{
					issuedStatusElem.visibility = tabVisible && issuedStatusText.Length > 0;
				}
				if ((Object)(object)issuedHeaderElem != (Object)null)
				{
					issuedHeaderElem.visibility = tabVisible;
				}
				Relabel(issuedHeader, "<size=115%>Moderators you've promoted</size>  <color=#6f7d88>" + ModStyle.CountBadge(issued.Count, "0.19em") + "</color>");
			}
			held = (from t in ClientTokenStore.Entries()
				orderby hostSteamId != null && t.HostSteamId == hostSteamId descending
				select t).ToList();
			if (held.Count > heldRows.Length)
			{
				Plugin.Logger.LogWarning((object)$"Access tab: {held.Count} held grants exceed {heldRows.Length} rows; reopen the panel to see all");
			}
			for (int num2 = 0; num2 < heldRows.Length; num2++)
			{
				bool flag2 = num2 < held.Count;
				if ((Object)(object)heldElems[num2] != (Object)null)
				{
					heldElems[num2].visibility = tabVisible && flag2;
				}
				if (flag2 && (Object)(object)heldRows[num2] != (Object)null)
				{
					((TMP_Text)heldRows[num2].labelTMP).text = HeldCaption(held[num2], hostSteamId);
				}
			}
			if ((Object)(object)heldEmptyElem != (Object)null)
			{
				heldEmptyElem.visibility = tabVisible && held.Count == 0;
			}
			if ((Object)(object)heldStatusElem != (Object)null)
			{
				heldStatusElem.visibility = tabVisible && heldStatusText.Length > 0;
			}
			if ((Object)(object)heldHeaderElem != (Object)null)
			{
				heldHeaderElem.visibility = tabVisible;
			}
			Relabel(heldHeader, "<size=115%>Hosts who gave you access</size>  <color=#6f7d88>" + ModStyle.CountBadge(held.Count, "0.19em") + "</color>");
			TabCount = (builtAsHost ? issued.Count : held.Count);
			if (TabCount != lastReportedCount)
			{
				lastReportedCount = TabCount;
				CountChanged?.Invoke();
			}
		}

		private void RebuildPresence()
		{
			presentSteamIds.Clear();
			Player[] playerList = PhotonNetwork.PlayerList;
			if (playerList == null)
			{
				return;
			}
			Player[] array = playerList;
			foreach (Player val in array)
			{
				if (val != null)
				{
					string text = PlayerRegistry.Instance.Resolve(val.ActorNumber);
					if (!string.IsNullOrEmpty(text))
					{
						presentSteamIds.Add(text);
					}
				}
			}
		}

		private static string? CurrentHostSteamId()
		{
			Player masterClient = PhotonNetwork.MasterClient;
			if (masterClient == null)
			{
				return null;
			}
			return PlayerRegistry.Instance.Resolve(masterClient.ActorNumber);
		}

		private static string Prefix(string token)
		{
			return ((token.Length > 12) ? token.Substring(0, 12) : token) + "…";
		}

		private string IssuedCaption(IssuedToken t)
		{
			bool flag = t.Name.Length == 0;
			string text = MenuUiHelpers.SanitizePlayerName(t.Name, "(unnamed)");
			if (text.Length > 16)
			{
				text = MenuUiHelpers.TruncateSafe(text, 15) + "…";
			}
			string text2 = (flag ? "#8aa0b0" : "#66b2ff");
			string text3 = (flag ? "" : (presentSteamIds.Contains(t.SteamId) ? "<color=#9bd17a>in lobby</color>  " : "<color=#6f7d88>offline</color>  "));
			return "<color=" + text2 + ">●</color> " + text + "  <size=75%>" + text3 + "<color=#6f7d88>" + Prefix(t.Token) + "</color></size>";
		}

		private static string HeldCaption(HeldToken entry, string? hostSteamId)
		{
			string text = HostDisplayName(entry);
			string text2 = ((text.Length > 16) ? (MenuUiHelpers.TruncateSafe(text, 15) + "…") : text);
			string text3 = ((hostSteamId != null && entry.HostSteamId == hostSteamId) ? "<color=#9bd17a>this lobby</color>  " : "");
			string text4 = "";
			string text5 = MenuUiHelpers.SanitizePlayerName(entry.Lobby, "");
			if (text5.Length > 0 && !string.Equals(text5, text, StringComparison.OrdinalIgnoreCase))
			{
				if (text5.Length > 16)
				{
					text5 = MenuUiHelpers.TruncateSafe(text5, 15) + "…";
				}
				text4 = "<color=#6f7d88>" + text5 + "</color>  ";
			}
			return "<color=#ffd24a>●</color> " + text2 + "  <size=75%>" + text3 + text4 + "<color=#6f7d88>" + Prefix(entry.Token) + "</color></size>";
		}

		private static string HostDisplayName(HeldToken entry)
		{
			PlayerAvatar val = SemiFunc.PlayerGetFromSteamID(entry.HostSteamId);
			if ((Object)(object)val != (Object)null)
			{
				return MenuUiHelpers.SanitizePlayerName(SemiFunc.PlayerGetName(val), entry.HostSteamId);
			}
			if (entry.HostName.Length > 0)
			{
				string text = MenuUiHelpers.SanitizePlayerName(entry.HostName, "");
				if (text.Length > 0)
				{
					return text;
				}
			}
			return entry.HostSteamId;
		}

		private void OnIssuedClicked(int slot)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			if (slot >= 0 && slot < issued.Count && SemiFunc.IsMasterClient())
			{
				IssuedToken token = issued[slot];
				bool unlabeled = token.Name.Length == 0;
				string name = MenuUiHelpers.SanitizePlayerName(token.Name, "(unnamed)");
				string message = (unlabeled ? ("Take back this unnamed access?\n" + Prefix(token.Token) + "\nAnyone still holding a copy loses moderator immediately.") : ("Take moderator access back from " + name + "?\n" + token.SteamId + "\nIt stops working immediately, rejoins included."));
				MenuUiHelpers.ShowTwoOptionPopup("Revoke access", ConfirmHeaderColor, message, delegate
				{
					ModerationActions.RevokeIssuedToken(token.Token);
					SetIssuedStatus(unlabeled ? ("Revoked unnamed access (" + Prefix(token.Token) + ")") : ("Revoked " + name + "'s access"));
					Refresh();
				}, null, "Revoke", "Keep");
			}
		}

		private void OnHeldClicked(int slot)
		{
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			if (slot >= 0 && slot < held.Count)
			{
				HeldToken entry = held[slot];
				string label = HostDisplayName(entry);
				string text = ((label == entry.HostSteamId) ? "" : ("\n" + entry.HostSteamId));
				MenuUiHelpers.ShowTwoOptionPopup("Forget access", ConfirmHeaderColor, "Forget your moderator access to " + label + "?" + text + "\nYou would need to be promoted again by that host.", delegate
				{
					ClientTokenStore.Remove(entry.HostSteamId);
					SetHeldStatus("Forgot your access to " + label);
					Refresh();
				}, null, "Forget", "Keep");
			}
		}

		private (REPOButton?[], REPOScrollViewElement?[]) BuildRowPool(int count, Action<int> onClick)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected O, but got Unknown
			REPOButton?[] rows = (REPOButton?[])(object)new REPOButton[count];
			REPOScrollViewElement[] array = (REPOScrollViewElement[])(object)new REPOScrollViewElement[count];
			for (int i = 0; i < count; i++)
			{
				int slot = i;
				page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
				{
					//IL_0027: Unknown result type (might be due to invalid IL or missing references)
					//IL_002d: Unknown result type (might be due to invalid IL or missing references)
					//IL_005b: Unknown result type (might be due to invalid IL or missing references)
					REPOButton val = MenuAPI.CreateREPOButton("", (Action)delegate
					{
						onClick(slot);
					}, sv, default(Vector2));
					((TMP_Text)val.labelTMP).richText = true;
					((TMP_Text)val.labelTMP).fontSize = 14f;
					val.overrideButtonSize = new Vector2(250f, 24f);
					rows[slot] = val;
					return ((REPOElement)val).rectTransform;
				}, 0f, 2f);
				array[i] = (((Object)(object)rows[i] != (Object)null) ? ((Component)rows[i]).GetComponent<REPOScrollViewElement>() : null);
			}
			return (rows, array);
		}

		private void AddStaticLabel(string richText)
		{
			REPOScrollViewElement val = ElemOf(MakeLabel(richText));
			if ((Object)(object)val != (Object)null)
			{
				staticElems.Add(val);
			}
		}

		private REPOLabel? MakeLabel(string richText)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			REPOLabel made = null;
			page.AddElementToScrollView((ScrollViewBuilderDelegate)delegate(Transform sv)
			{
				//IL_0009: 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)
				REPOLabel val = MenuAPI.CreateREPOLabel(richText, sv, default(Vector2));
				((TMP_Text)val.labelTMP).richText = true;
				((TMP_Text)val.labelTMP).fontSize = 14f;
				MenuUiHelpers.SizeWrappedLabel(val, richText, 250f);
				made = val;
				return ((REPOElement)val).rectTransform;
			}, 0f, 6f);
			return made;
		}

		private static string Hint(string text)
		{
			return "<size=75%><color=#6f7d88>" + text + "</color></size>";
		}

		private static REPOScrollViewElement? ElemOf(REPOLabel? label)
		{
			if (!((Object)(object)label != (Object)null))
			{
				return null;
			}
			return ((Component)label).GetComponent<REPOScrollViewElement>();
		}

		private static void Relabel(REPOLabel? label, string text)
		{
			if (!((Object)(object)label == (Object)null))
			{
				((TMP_Text)label.labelTMP).text = text;
				MenuUiHelpers.SizeWrappedLabel(label, text, 250f);
			}
		}

		private void SetIssuedStatus(string text)
		{
			issuedStatusText = text;
			Relabel(issuedStatus, (text.Length == 0) ? "" : ("<size=75%><color=#ffa726>" + text + "</color></size>"));
		}

		private void SetHeldStatus(string text)
		{
			heldStatusText = text;
			Relabel(heldStatus, (text.Length == 0) ? "" : ("<size=75%><color=#6f7d88>" + text + "</color></size>"));
		}
	}
}
namespace SharePermissions.Players
{
	internal static class AuthorizedActors
	{
		private static readonly HashSet<int> actors = new HashSet<int>();

		private static readonly Dictionary<int, string> actorToken = new Dictionary<int, string>();

		internal static bool Contains(int actor)
		{
			return actors.Contains(actor);
		}

		internal static bool IsModeratorActor(int actor)
		{
			return actors.Contains(actor);
		}

		internal static int[] Snapshot()
		{
			int[] array = new int[actors.Count];
			actors.CopyTo(array);
			return array;
		}

		internal static void Authorize(int actor, string? token)
		{
			actors.Add(actor);
			if (!string.IsNullOrEmpty(token))
			{
				actorToken[actor] = token;
			}
		}

		internal static string? TokenFor(int actor)
		{
			if (!actorToken.TryGetValue(actor, out string value))
			{
				return null;
			}
			return value;
		}

		internal static List<int> ActorsHolding(string? token)
		{
			if (!string.IsNullOrEmpty(token))
			{
				return (from kv in actorToken
					where kv.Value == token
					select kv.Key).ToList();
			}
			return new List<int>();
		}

		internal static void RemoveActor(int actor)
		{
			actors.Remove(actor);
			actorToken.Remove(actor);
		}

		internal static void RevokeToken(string? token)
		{
			foreach (int item in ActorsHolding(token))
			{
				RemoveActor(item);
			}
		}

		internal static void Clear()
		{
			actors.Clear();
			actorToken.Clear();
		}
	}
	internal readonly struct HeldToken
	{
		internal readonly string HostSteamId;

		internal readonly string Token;

		internal readonly string HostName;

		internal readonly string Lobby;

		internal HeldToken(string hostSteamId, string token, string hostName, string lobby)
		{
			HostSteamId = hostSteamId;
			Token = token;
			HostName = hostName;
			Lobby = lobby;
		}
	}
	internal static class ClientTokenStore
	{
		private const int MaxLabelChars = 24;

		private static Dictionary<string, HeldToken>? map;

		private static bool suppressReload;

		private static Dictionary<string, HeldToken> Map => map ?? (map = Parse(ModConfig.MyModeratorTokens.Value));

		internal static void InvalidateCache()
		{
			if (!suppressReload)
			{
				map = null;
			}
		}

		internal static string? Get(string? hostSteamId)
		{
			if (string.IsNullOrEmpty(hostSteamId) || !Map.TryGetValue(hostSteamId, out var value))
			{
				return null;
			}
			return value.Token;
		}

		internal static void Save(string? hostSteamId, string? token, string? hostName, string? lobby)
		{
			if (string.IsNullOrEmpty(hostSteamId) || !TokenGenerator.IsHexToken(token))
			{
				return;
			}
			string text = SafeLabel(hostName);
			string text2 = SafeLabel(lobby);
			if (Map.TryGetValue(hostSteamId, out var value))
			{
				if (text.Length == 0)
				{
					text = value.HostName;
				}
				if (text2.Length == 0)
				{
					text2 = value.Lobby;
				}
				if (value.Token == token && value.HostName == text && value.Lobby == text2)
				{
					return;
				}
			}
			Map[hostSteamId] = new HeldToken(hostSteamId, token, text, text2);
			Persist();
		}

		internal static void UpdateLabel(string? hostSteamId, string? hostName, string? lobby)
		{
			if (!string.IsNullOrEmpty(hostSteamId) && Map.TryGetValue(hostSteamId, out var value))
			{
				string text = SafeLabel(hostName);
				string text2 = SafeLabel(lobby);
				if (text.Length == 0)
				{
					text = value.HostName;
				}
				if (text2.Length == 0)
				{
					text2 = value.Lobby;
				}
				if (!(value.HostName == text) || !(value.Lobby == text2))
				{
					Map[hostSteamId] = new HeldToken(hostSteamId, value.Token, text, text2);
					Persist();
				}
			}
		}

		internal static void Remove(string? hostSteamId)
		{
			if (!string.IsNullOrEmpty(hostSteamId) && Map.Remove(hostSteamId))
			{
				Persist();
			}
		}

		internal static List<HeldToken> Entries()
		{
			return Map.Values.OrderBy<HeldToken, string>((HeldToken t) => t.HostSteamId, StringComparer.Ordinal).ToList();
		}

		private static string SafeLabel(string? label)
		{
			string text = (label ?? "").Trim();
			if (text.Length <= 24)
			{
				return text;
			}
			int num = 24;
			if (char.IsHighSurrogate(text[num - 1]))
			{
				num--;
			}
			return text.Substring(0, num);
		}

		private static Dictionary<string, HeldToken> Parse(string? csv)
		{
			Dictionary<string, HeldToken> dictionary = new Dictionary<string, HeldToken>();
			if (string.IsNullOrWhiteSpace(csv))
			{
				return dictionary;
			}
			string[] array = csv.Split(',');
			foreach (string text in array)
			{
				string text2 = text.Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				string[] array2 = text2.Split(':');
				if (array2.Length >= 2)
				{
					string text3 = array2[0].Trim();
					string text4 = array2[1].Trim();
					if (text3.Length != 0 && ulong.TryParse(text3, out var _) && TokenGenerator.IsHexToken(text4))
					{
						string hostName = ((array2.Length > 2) ? SafeLabel(DecodeLabel(array2[2].Trim())) : "");
						string lobby = ((array2.Length > 3) ? SafeLabel(DecodeLabel(array2[3].Trim())) : "");
						dictionary[text3] = new HeldToken(text3, text4, hostName, lobby);
					}
				}
			}
			return dictionary;
		}

		private static string DecodeLabel(string base64)
		{
			if (base64.Length == 0)
			{
				return "";
			}
			try
			{
				return Encoding.UTF8.GetString(Convert.FromBase64String(base64));
			}
			catch
			{
				return "";
			}
		}

		private static string EncodeEntry(HeldToken t)
		{
			if (t.HostName.Length == 0 && t.Lobby.Length == 0)
			{
				return t.HostSteamId + ":" + t.Token;
			}
			string text = ((t.HostName.Length == 0) ? "" : Convert.ToBase64String(Encoding.UTF8.GetBytes(t.HostName)));
			if (t.Lobby.Length == 0)
			{
				return t.HostSteamId + ":" + t.Token + ":" + text;
			}
			string text2 = Convert.ToBase64String(Encoding.UTF8.GetBytes(t.Lobby));
			return t.HostSteamId + ":" + t.Token + ":" + text + ":" + text2;
		}

		private static void Persist()
		{
			string text = string.Join(",", Map.Values.OrderBy<HeldToken, string>((HeldToken t) => t.HostSteamId, StringComparer.Ordinal).Select(EncodeEntry));
			if (ModConfig.MyModeratorTokens.Value == text)
			{
				return;
			}
			suppressReload = true;
			try
			{
				ModConfig.MyModeratorTokens.Value = text;
			}
			finally
			{
				suppressReload = false;
			}
		}
	}
	internal static class HostCapabilities
	{
		internal const string CapPersistentBan = "pban";

		internal const string CapAdminMenu = "ram";

		internal static bool PersistentBan { get; private set; }

		internal static bool AdminMenu { get; private set; }

		internal static void Set(string? capsCsv)
		{
			bool flag = false;
			bool flag2 = false;
			string[] array = (capsCsv ?? "").Split(',');
			foreach (string text in array)
			{
				string text2 = text.Trim();
				if (text2 == "pban")
				{
					flag = true;
				}
				else if (text2 == "ram")
				{
					flag2 = true;
				}
			}
			if (flag != PersistentBan)
			{
				Plugin.Logger.LogInfo((object)("Host capabilities: persistent ban " + (flag ? "available" : "unavailable")));
			}
			if (flag2 != AdminMenu)
			{
				Plugin.Logger.LogInfo((object)("Host capabilities: admin menu " + (flag2 ? "granted" : "not granted")));
			}
			PersistentBan = flag;
			AdminMenu = flag2;
		}

		internal static void Clear()
		{
			PersistentBan = false;
			AdminMenu = false;
		}
	}
	internal sealed class Moderators
	{
		internal static readonly Color ModeratorColor = ModStyle.RoleModerator;

		private readonly HashSet<string> moderatorSteamIds = new HashSet<string>();

		internal static Moderators Instance { get; } = new Moderators();

		internal event Action? Changed;

		private Moderators()
		{
		}

		internal void AddModerator(string? steamId)
		{
			if (!string.IsNullOrEmpty(steamId) && moderatorSteamIds.Add(steamId))
			{
				Plugin.Logger.LogInfo((object)("Added moderator: " + steamId));
				this.Changed?.Invoke();
			}
		}

		internal void RemoveModerator(string steamId)
		{
			if (moderatorSteamIds.Remove(steamId))
			{
				Plugin.Logger.LogInfo((object)("Removed moderator: " + steamId));
				this.Changed?.Invoke();
			}
		}

		internal bool IsModerator(string? steamId)
		{
			if (!string.IsNullOrEmpty(steamId))
			{
				return moderatorSteamIds.Contains(steamId);
			}
			return false;
		}

		internal bool IsModerator(PlayerAvatar? player)
		{
			if ((Object)(object)player != (Object)null)
			{
				return IsModerator(SemiFunc.PlayerGetSteamID(player));
			}
			return false;
		}

		internal List<string> GetAllModerators()
		{
			return moderatorSteamIds.ToList();
		}

		internal void Clear()
		{
			if (moderatorSteamIds.Count != 0)
			{
				moderatorSteamIds.Clear();
				Plugin.Logger.LogInfo((object)"Cleared all moderators");
				this.Changed?.Invoke();
			}
		}
	}
	internal sealed class ModUsers
	{
		private readonly HashSet<string> modUserSteamIds = new HashSet<string>();

		internal static ModUsers Instance { get; } = new ModUsers();

		internal event Action? Changed;

		private ModUsers()
		{
		}

		internal void Add(string? steamId)
		{
			if (!string.IsNullOrEmpty(steamId) && modUserSteamIds.Add(steamId))
			{
				Plugin.Logger.LogInfo((object)("Added mod user: " + steamId));
				this.Changed?.Invoke();
			}
		}

		internal void Remove(string steamId)
		{
			if (modUserSteamIds.Remove(steamId))
			{
				Plugin.Logger.LogInfo((object)("Removed mod user: " + steamId));
				this.Changed?.Invoke();
			}
		}

		internal bool Contains(string? steamId)
		{
			if (!string.IsNullOrEmpty(steamId))
			{
				return modUserSteamIds.Contains(steamId);
			}
			return false;
		}

		internal List<string> GetAll()
		{
			return modUserSteamIds.ToList();
		}

		internal void Clear()
		{
			if (modUserSteamIds.Count != 0)
			{
				modUserSteamIds.Clear();
				Plugin.Logger.LogInfo((object)"Cleared all mod users");
				this.Changed?.Invoke();
			}
		}
	}
	internal static class NameColors
	{
		internal const string DefaultHostHex = "ffd24a";

		internal const string DefaultModeratorHex = "66b2ff";

		private const string KeyHost = "host";

		private const string KeyModerator = "mod";

		private const char WirePairSeparator = ';';

		private const char WireKeySeparator = '=';

		private const char ConfigPairSeparator = ',';

		private const char ConfigKeySeparator = ':';

		internal const int MaxOverrides = 64;

		private static readonly Dictionary<string, Color> Overrides = new Dictionary<string, Color>();

		internal static int Version { get; private set; }

		internal static bool IsApplyingConfig { get; private set; }

		internal static Color HostColor { get; private set; } = Hex("ffd24a");

		internal static Color ModeratorColor { get; private set; } = Hex("66b2ff");

		internal static bool Advertised { get; private set; }

		internal static Color? Resolve(string? steamId, ModRole role)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			if (!Advertised && !SemiFunc.IsMasterClient())
			{
				return null;
			}
			if (!string.IsNullOrEmpty(steamId) && Overrides.TryGetValue(steamId, out var value))
			{
				return value;
			}
			return role switch
			{
				ModRole.Host => HostColor, 
				ModRole.Moderator => ModeratorColor, 
				_ => null, 
			};
		}

		internal static Color? ResolveForAvatar(PlayerAvatar? avatar)
		{
			if (!((Object)(object)avatar == (Object)null))
			{
				return Resolve(SemiFunc.PlayerGetSteamID(avatar), RoleResolver.ResolveByAvatar(avatar));
			}
			return null;
		}

		internal static Color? GetOverride(string? steamId)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(steamId) || !Overrides.TryGetValue(steamId, out var value))
			{
				return null;
			}
			return value;
		}

		internal static void ApplyLocalConfig()
		{
			//IL_0015: 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_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_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			Advertised = false;
			HostColor = ParseOr(ModConfig.NameColorHost.Value, Hex("ffd24a"));
			ModeratorColor = ParseOr(ModConfig.NameColorModerator.Value, Hex("66b2ff"));
			Overrides.Clear();
			foreach (var (key, value) in ParseEntries(ModConfig.NameColorOverrides.Value, ',', ':'))
			{
				if (IsSteamId(key) && Overrides.Count < 64)
				{
					Overrides[key] = value;
				}
			}
			Version++;
		}

		internal static void Clear()
		{
			ApplyLocalConfig();
		}

		internal static void SetHostColor(Color color)
		{
			//IL_0000: 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)
			HostColor = color;
			WriteConfig(ModConfig.NameColorHost, ToHex(color));
			Version++;
		}

		internal static void SetModeratorColor(Color color)
		{
			//IL_0000: 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)
			ModeratorColor = color;
			WriteConfig(ModConfig.NameColorModerator, ToHex(color));
			Version++;
		}

		private static void WriteConfig(ConfigEntry<string> entry, string value)
		{
			if (entry.Value == value)
			{
				return;
			}
			IsApplyingConfig = true;
			try
			{
				entry.Value = value;
			}
			finally
			{
				IsApplyingConfig = false;
			}
		}

		internal static void SetOverride(string? steamId, Color? color)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			if (!IsSteamId(steamId))
			{
				return;
			}
			if (color.HasValue)
			{
				Color valueOrDefault = color.GetValueOrDefault();
				if (!Overrides.ContainsKey(steamId) && Overrides.Count >= 64)
				{
					Plugin.Logger.LogWarning((object)$"Name color override ignored: already at the {64} cap");
					return;
				}
				Overrides[steamId] = valueOrDefault;
			}
			else if (!Overrides.Remove(steamId))
			{
				return;
			}
			SaveOverrides();
			Version++;
		}

		private static void SaveOverrides()
		{
			string value = string.Join(','.ToString(), from kv in Overrides
				orderby kv.Key
				select $"{kv.Key}{':'}{ToHex(kv.Value)}");
			WriteConfig(ModConfig.NameColorOverrides, value);
		}

		internal static string ToWire()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("host").Append('=').Append(ToHex(HostColor));
			stringBuilder.Append(';').Append("mod").Append('=')
				.Append(ToHex(ModeratorColor));
			int num = 0;
			foreach (KeyValuePair<string, Color> item in Overrides.OrderBy<KeyValuePair<string, Color>, string>((KeyValuePair<string, Color> kv) => kv.Key))
			{
				if (num++ >= 64)
				{
					break;
				}
				stringBuilder.Append(';').Append(item.Key).Append('=')
					.Append(ToHex(item.Value));
			}
			return stringBuilder.ToString();
		}

		internal static void SetFromWire(string? payload)
		{
			//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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_0064: 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_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			Color hostColor = Hex("ffd24a");
			Color moderatorColor = Hex("66b2ff");
			Dictionary<string, Color> dictionary = new Dictionary<string, Color>();
			foreach (var (text, val) in ParseEntries(payload, ';', '='))
			{
				if (text == "host")
				{
					hostColor = val;
				}
				else if (text == "mod")
				{
					moderatorColor = val;
				}
				else if (IsSteamId(text) && dictionary.Count < 64)
				{
					dictionary[text] = val;
				}
			}
			HostColor = hostColor;
			ModeratorColor = moderatorColor;
			Overrides.Clear();
			foreach (KeyValuePair<string, Color> item in dictionary)
			{
				Overrides[item.Key] = item.Value;
			}
			Advertised = true;
			Version++;
		}

		private static IEnumerable<(string Key, Color Color)> ParseEntries(string? text, char pairSeparator, char keySeparator)
		{
			if (string.IsNullOrWhiteSpace(text))
			{
				yield break;
			}
			string[] array = text.Split(pairSeparator);
			foreach (string text2 in array)
			{
				int num = text2.IndexOf(keySeparator);
				if (num > 0)
				{
					string text3 = text2.Substring(0, num).Trim();
					if (text3.Length != 0 && TryParseHex(text2.Substring(num + 1), out var color))
					{
						yield return (Key: text3, Color: color);
					}
				}
			}
		}

		internal static bool TryParseHex(string? hex, out Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			color = Color.white;
			if (hex == null)
			{
				return false;
			}
			string text = hex.Trim();
			if (text.StartsWith("#"))
			{
				text = text.Substring(1);
			}
			if (text.Length != 6)
			{
				return false;
			}
			string text2 = text;
			foreach (char c in text2)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F'))
				{
					return false;
				}
			}
			if (!int.TryParse(text, NumberStyles.HexNumber, CultureInfo.InvariantCulture, out var result))
			{
				return false;
			}
			color = Hex(result);
			return true;
		}

		internal static Color Dimmed(Color color, float factor)
		{
			//IL_0000: 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)
			//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)
			return new Color(color.r * factor, color.g * factor, color.b * factor, 1f);
		}

		internal static string ToHex(Color color)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			return $"{Channel(color.r):x2}{Channel(color.g):x2}{Channel(color.b):x2}";
			static int Channel(float v)
			{
				return Mathf.Clamp(Mathf.RoundToInt(v * 255f), 0, 255);
			}
		}

		private static Color ParseOr(string? hex, Color fallback)
		{
			//IL_000c: 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)
			if (!TryParseHex(hex, out var color))
			{
				return fallback;
			}
			return color;
		}

		private static bool IsSteamId(string? key)
		{
			ulong result;
			if (!string.IsNullOrEmpty(key))
			{
				return ulong.TryParse(key, out result);
			}
			return false;
		}

		private static Color Hex(string hex)
		{
			//IL_0010: 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)
			if (!TryParseHex(hex, out var color))
			{
				return Color.white;
			}
			return color;
		}

		private static Color Hex(int rgb)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			return new Color((float)((rgb >> 16) & 0xFF) / 255f, (float)((rgb >> 8) & 0xFF) / 255f, (float)(rgb & 0xFF) / 255f);
		}
	}
	internal struct NameColorCache
	{
		private const float RefreshInterval = 0.2f;

		private float nextResolve;

		private int version;

		private Color? tint;

		internal Color? Get(PlayerAvatar? avatar)
		{
			if (version != NameColors.Version || Time.time >= nextResolve)
			{
				version = NameColors.Version;
				nextResolve = Time.time + 0.2f;
				tint = NameColors.ResolveForAvatar(avatar);
			}
			return tint;
		}
	}
	internal static class NotesStore
	{
		private static string? filePath;

		private static NotesState? state;

		private static string FilePath
		{
			get
			{
				if (!string.IsNullOrEmpty(filePath))
				{
					return filePath;
				}
				try
				{
					filePath = Path.Combine(Paths.ConfigPath, "SharePermissions.Notes.json");
				}
				catch
				{
					filePath = Path.Combine(Application.persistentDataPath, "SharePermissions.Notes.json");
				}
				return filePath;
			}
		}

		private static NotesState State
		{
			get
			{
				if (state == null)
				{
					Load();
				}
				return state;
			}
		}

		private static long NowUnix => DateTimeOffset.UtcNow.ToUnixTimeSeconds();

		private static void Load()
		{
			state = new NotesState();
			try
			{
				if (!File.Exists(FilePath))
				{
					return;
				}
				string json = File.ReadAllText(FilePath);
				if (PlayerNotesCore.TryParseJson(json, NowUnix, out NotesState notesState))
				{
					state = notesState;
					return;
				}
				string text = FilePath + ".bak";
				try
				{
					if (File.Exists(text))
					{
						File.Delete(text);
					}
					File.Move(FilePath, text);
					Plugin.Logger.LogWarning((object)("Player notes file was corrupt - moved to " + text + ", starting empty"));
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogWarning((object)("Player notes file corrupt and quarantine failed (" + ex.Message + ") - starting empty"));
				}
			}
			catch (Exception ex2)
			{
				Plugin.Logger.LogWarning((object)("Player notes load failed: " + ex2.Message + " - starting empty"));
			}
		}

		private static void Save()
		{
			try
			{
				File.WriteAllText(FilePath, PlayerNotesCore.ToJson(State));
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("Player notes save failed: " + ex.Message));
			}
		}

		internal static IReadOnlyList<PlayerNote> All()
		{
			return State.Notes;
		}

		internal static IReadOnlyList<string> Tombstones()
		{
			return State.TombstoneOrder;
		}

		internal static int CountFor(string? steamId)
		{
			return PlayerNotesCore.CountFor(State, steamId);
		}

		internal static List<PlayerNote> For(string? steamId)
		{
			return PlayerNotesCore.For(State, steamId);
		}

		internal static PlayerNote? Find(string id)
		{
			foreach (PlayerNote note in State.Notes)
			{
				if (note.Id == id)
				{
					return note;
				}
			}
			return null;
		}

		internal static bool TryAddLocal(string targetSteamId, string? rawText, string authorSteamId, string authorName, string lobbyName, out PlayerNote note, out string reason)
		{
			note = default(PlayerNote);
			reason = "";
			string text = PlayerNotesCore.SanitizeText(rawText);
			if (text.Length == 0)
			{
				reason = "empty";
				return false;
			}
			if (!PlayerNotesCore.IsSteamId(targetSteamId))
			{
				reason = "no-steamid";
				return false;
			}
			note = new PlayerNote(PlayerNotesCore.NewId(), targetSteamId, text, PlayerNotesCore.IsSteamId(authorSteamId) ? authorSteamId : "0", PlayerNotesCore.SanitizeName(authorName, 24), PlayerNotesCore.SanitizeName(lobbyName, 40), NowUnix);
			if (!PlayerNotesCore.TryAdd(State, in note, out reason))
			{
				return false;
			}
			Save();
			return true;
		}

		internal static void ApplyIncoming(IEnumerable<string?> items, out List<PlayerNote> addedNotes, out List<string> addedTombstones)
		{
			addedNotes = new List<PlayerNote>();
			addedTombstones = new List<string>();
			bool flag = false;
			long nowUnix = NowUnix;
			foreach (string item in items)
			{
				if (string.IsNullOrEmpty(item))
				{
					continue;
				}
				if (item.IndexOf(':') >= 0)
				{
					if (PlayerNotesCore.TryDecode(item, nowUnix, out var note) && PlayerNotesCore.TryAdd(State, in note, out string _))
					{
						addedNotes.Add(note);
						flag = true;
					}
				}
				else if (PlayerNotesCore.IsHexId(item) && !State.TombstoneSet.Contains(item))
				{
					PlayerNotesCore.Delete(State, item);
					addedTombstones.Add(item);
					flag = true;
				}
			}
			if (flag)
			{
				Save();
			}
		}

		internal static bool Delete(string id)
		{
			if (!PlayerNotesCore.IsHexId(id))
			{
				return false;
			}
			bool hasValue = Find(id).HasValue;
			if (!hasValue && State.TombstoneSet.Contains(id))
			{
				return false;
			}
			PlayerNotesCore.Delete(State, id);
			Save();
			return hasValue;
		}
	}
	internal readonly struct PlayerNote
	{
		internal readonly string Id;

		internal readonly string TargetSteamId;

		internal readonly string Text;

		internal readonly string AuthorSteamId;

		internal readonly string AuthorName;

		internal readonly string LobbyName;

		internal readonly long CreatedUnix;

		internal PlayerNote(string id, string targetSteamId, string text, string authorSteamId, string authorName, string lobbyName, long createdUnix)
		{
			Id = id;
			TargetSteamId = targetSteamId;
			Text = text;
			AuthorSteamId = authorSteamId;
			AuthorName = authorName;
			LobbyName = lobbyName;
			CreatedUnix = createdUnix;
		}
	}
	internal sealed class NotesState
	{
		internal readonly List<PlayerNote> Notes = new List<PlayerNote>();

		internal readonly List<string> TombstoneOrder = new List<string>();

		internal readonly HashSet<string> TombstoneSet = new HashSet<string>(StringComparer.Ordinal);
	}
	internal static class PlayerNotesCore
	{
		internal const int MaxText = 200;

		internal const int MaxAuthorName = 24;

		internal const int MaxLobbyName = 40;

		internal const int MaxPerTarget = 20;

		internal const int MaxTotal = 2000;

		internal const int MaxTombstones = 2000;

		internal const int ChunkSize = 15;

		internal const string WireMore = "more";

		internal const string WireDone = "done";

		private const long MaxFutureSkewSeconds = 86400L;

		internal static string NewId()
		{
			byte[] array = new byte[8];
			using (RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create())
			{
				randomNumberGenerator.GetBytes(array);
			}
			StringBuilder stringBuilder = new StringBuilder(16);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2"));
			}
			return stringBuilder.ToString();
		}

		internal static string SanitizeText(string? raw)
		{
			return Sanitize(raw, 200);
		}

		internal static string SanitizeName(string? raw, int max)
		{
			return Sanitize(raw, max);
		}

		private static string Sanitize(string? raw, int max)
		{
			if (string.IsNullOrEmpty(raw))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(raw.Length);
			for (int i = 0; i < raw.Length; i++)
			{
				char c = raw[i];
				if (char.IsControl(c))
				{
					continue;
				}
				switch (c)
				{
				case '<':
					break;
				default:
					stringBuilder.Append(c);
					continue;
				case '>':
				case '[':
				case ']':
					continue;
				}
				int num = raw.IndexOf('>', i + 1);
				if (num >= 0)
				{
					i = num;
					continue;
				}
				for (int j = i + 1; j < raw.Length; j++)
				{
					char c2 = raw[j];
					if (!char.IsControl(c2) && c2 != '<' && c2 != '>' && c2 != '[' && c2 != ']')
					{
						stringBuilder.Append(c2);
					}
				}
				break;
			}
			string text = stringBuilder.ToString().Trim();
			if (text.Length <= max)
			{
				return text;
			}
			int num2 = max;
			if (char.IsHighSurrogate(text[num2 - 1]))
			{
				num2--;
			}
			return text.Substring(0, num2);
		}

		internal static bool IsHexId(string? s)
		{
			if (s == null || s.Length != 16)
			{
				return false;
			}
			foreach (char c in s)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
				{
					return false;
				}
			}
			return true;
		}

		internal static bool LooksLikeRoomGuid(string? s)
		{
			if (s == null || s.Length != 36)
			{
				return false;
			}
			for (int i = 0; i < 36; i++)
			{
				char c = s[i];
				if (i == 8 || i == 13 || i == 18 || i == 23)
				{
					if (c != '-')
					{
						return false;
					}
				}
				else if ((c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F'))
				{
					return false;
				}
			}
			return true;
		}

		internal static bool IsSteamId(string? s)
		{
			if (string.IsNullOrEmpty(s) || s.Length > 20)
			{
				return false;
			}
			foreach (char c in s)
			{
				if (c < '0' || c > '9')
				{
					return false;
				}
			}
			return true;
		}

		internal static string Encode(in PlayerNote n)
		{
			return $"{n.Id}:{n.TargetSteamId}:{n.AuthorSteamId}:{B64(n.AuthorName)}:{B64(n.Text)}:{B64(n.LobbyName)}:{n.CreatedUnix}";
		}

		internal static bool TryDecode(string? item, long nowUnix, out PlayerNote note)
		{
			note = default(PlayerNote);
			if (string.IsNullOrEmpty(item))
			{
				return false;
			}
			string[] array = item.Split(':');
			if (array.Length != 7)
			{
				return false;
			}
			if (!IsHexId(array[0]) || !IsSteamId(array[1]) || !IsSteamId(array[2]))
			{
				return false;
			}
			if (!TryB64(array[3], out string decoded))
			{
				return false;
			}
			if (!TryB64(array[4], out string decoded2))
			{
				return false;
			}
			if (!TryB64(array[5], out string decoded3))
			{
				return false;
			}
			if (!long.TryParse(array[6], out var result) || result < 0 || result > nowUnix + 86400)
			{
				return false;
			}
			decoded2 = SanitizeText(decoded2);
			if (decoded2.Length == 0)
			{
				return false;
			}
			note = new PlayerNote(array[0], array[1], decoded2, array[2], SanitizeName(decoded, 24), SanitizeName(decoded3, 40), result);
			return true;
		}

		internal static bool TryAdd(NotesState state, in PlayerNote candidate, out string reason)
		{
			reason = "";
			if (state.TombstoneSet.Contains(candidate.Id))
			{
				reason = "deleted";
				return false;
			}
			foreach (PlayerNote note in state.Notes)
			{
				if (note.Id == candidate.Id)
				{
					reason = "duplicate";
					return false;
				}
			}
			int num = 0;
			foreach (PlayerNote note2 in state.Notes)
			{
				if (note2.TargetSteamId == candidate.TargetSteamId)
				{
					num++;
				}
			}
			if (num >= 20)
			{
				reason = "target-full";
				return false;
			}
			if (state.Notes.Count >= 2000)
			{
				EvictOldest(state);
			}
			state.Notes.Add(candidate);
			return true;
		}

		private static void EvictOldest(NotesState state)
		{
			if (state.Notes.Count == 0)
			{
				return;
			}
			int index = 0;
			for (int i = 1; i < state.Notes.Count; i++)
			{
				PlayerNote playerNote = state.Notes[i];
				PlayerNote playerNote2 = state.Notes[index];
				if (playerNote.CreatedUnix < playerNote2.CreatedUnix || (playerNote.CreatedUnix == playerNote2.CreatedUnix && string.CompareOrdinal(playerNote.Id, playerNote2.Id) < 0))
				{
					index = i;
				}
			}
			state.Notes.RemoveAt(index);
		}

		internal static void Delete(NotesState state, string id)
		{
			for (int num = state.Notes.Count - 1; num >= 0; num--)
			{
				if (state.Notes[num].Id == id)
				{
					state.Notes.RemoveAt(num);
				}
			}
			if (state.TombstoneSet.Add(id))
			{
				state.TombstoneOrder.Add(id);
				while (state.TombstoneOrder.Count > 2000)
				{
					state.TombstoneSet.Remove(state.TombstoneOrder[0]);
					state.TombstoneOrder.RemoveAt(0);
				}
			}
		}

		internal static int CountFor(NotesState state, string? steamId)
		{
			if (string.IsNullOrEmpty(steamId))
			{
				return 0;
			}
			int num = 0;
			foreach (PlayerNote note in state.Notes)
			{
				if (note.TargetSteamId == steamId)
				{
					num++;
				}
			}
			return num;
		}

		internal static List<PlayerNote> For(NotesState state, string? steamId)
		{
			List<PlayerNote> list = new List<PlayerNote>();
			if (string.IsNullOrEmpty(steamId))
			{
				return list;
			}
			foreach (PlayerNote note in state.Notes)
			{
				if (note.TargetSteamId == steamId)
				{
					list.Add(note);
				}
			}
			list.Sort(delegate(PlayerNote a, PlayerNote b)
			{
				int num = b.CreatedUnix.CompareTo(a.CreatedUnix);
				return (num == 0) ? string.CompareOrdinal(b.Id, a.Id) : num;
			});
			return list;
		}

		internal static string ToJson(NotesState state)
		{
			StringBuilder stringBuilder = new StringBuilder(64 + state.Notes.Count * 96);
			stringBuilder.Append("{\"v\":1,\"notes\":[");
			bool flag = true;
			foreach (PlayerNote note in state.Notes)
			{
				string text = Encode(note);
				if (text.IndexOf('"') < 0 && text.IndexOf('\\') < 0)
				{
					if (!flag)
					{
						stringBuilder.Append(',');
					}
					flag = false;
					stringBuilder.Append('"').Append(text).Append('"');
				}
			}
			stringBuilder.Append("],\"tombstones\":[");
			flag = true;
			foreach (string item in state.TombstoneOrder)
			{
				if (!flag)
				{
					stringBuilder.Append(',');
				}
				flag = false;
				stringBuilder.Append('"').Append(item).Append('"');
			}
			stringBuilder.Append("]}");
			return stringBuilder.ToString();
		}

		internal static bool TryParseJson(string? json, long nowUnix, out NotesState state)
		{
			state = new NotesState();
			if (string.IsNullOrWhiteSpace(json))
			{
				return false;
			}
			if (!TryExtractArray(json, "\"notes\"", out List<string> items))
			{
				return false;
			}
			if (!TryExtractArray(json, "\"tombstones\"", out List<string> items2))
			{
				return false;
			}
			foreach (string item in items)
			{
				if (TryDecode(item, nowUnix, out var note))
				{
					TryAdd(state, in note, out string _);
				}
			}
			foreach (string item2 in items2)
			{
				if (IsHexId(item2))
				{
					Delete(state, item2);
				}
			}
			return true;
		}

		private static bool TryExtractArray(string json, string key, out List<string> items)
		{
			items = new List<string>();
			int num = json.IndexOf(key, StringComparison.Ordinal);
			if (num < 0)
			{
				return false;
			}
			int num2 = json.IndexOf('[', num);
			int num3 = ((num2 < 0) ? (-1) : json.IndexOf(']', num2));
			if (num2 < 0 || num3 < 0)
			{
				return false;
			}
			int num4 = num2 + 1;
			while (num4 < num3)
			{
				int num5 = json.IndexOf('"', num4);
				if (num5 < 0 || num5 >= num3)
				{
					break;
				}
				int num6 = json.IndexOf('"', num5 + 1);
				if (num6 < 0 || num6 > num3)
				{
					return false;
				}
				string text = json.Substring(num5 + 1, num6 - num5 - 1);
				if (text.IndexOf('\\') >= 0)
				{
					return false;
				}
				items.Add(text);
				num4 = num6 + 1;
			}
			return true;
		}

		internal static List<List<string>> Chunk(List<string> items, int size)
		{
			List<List<string>> list = new List<List<string>>();
			for (int i = 0; i < items.Count; i += size)
			{
				list.Add(items.GetRange(i, Math.Min(size, items.Count - i)));
			}
			return list;
		}

		private static string B64(string s)
		{
			return Convert.ToBase64String(Encoding.UTF8.GetBytes(s ?? ""));
		}

		private static bool TryB64(string s, out string decoded)
		{
			decoded = "";
			try
			{
				decoded = Encoding.UTF8.GetString(Convert.FromBase64String(s));
				return true;
			}
			catch (FormatException)
			{
				return false;
			}
		}
	}
	internal sealed class PlayerRegistry
	{
		private readonly Dictionary<int, string> actorToSteamId = new Dictionary<int, string>();

		private readonly Dictionary<int, float> nextAvatarScanTime = new Dictionary<int, float>();

		private const float AvatarScanInterval = 1f;

		internal static PlayerRegistry Instance { get; } = new PlayerRegistry();

		private PlayerRegistry()
		{
		}

		internal string? TryGetSteamId(int actorNumber)
		{
			if (!actorToSteamId.TryGetValue(actorNumber, out string value))
			{
				return null;
			}
			return value;
		}

		internal string? BindIfAbsent(int actorNumber, string? steamId)
		{
			if (actorToSteamId.TryGetValue(actorNumber, out string value))
			{
				return value;
			}
			if (string.IsNullOrEmpty(steamId) || !ulong.TryParse(steamId, out var _))
			{
				return null;
			}
			actorToSteamId[actorNumber] = steamId;
			Plugin.Logger.LogInfo((object)$"Bound Steam ID for actor {actorNumber}: {steamId}");
			return steamId;
		}

		internal string? Resolve(int actorNumber)
		{
			if (actorToSteamId.TryGetValue(actorNumber, out string value))
			{
				return value;
			}
			Room currentRoom = PhotonNetwork.CurrentRoom;
			Player val = ((currentRoom != null) ? currentRoom.GetPlayer(actorNumber, false) : null);
			if (val != null && !string.IsNullOrEmpty(val.UserId))
			{
				string text = BindIfAbsent(actorNumber, val.UserId);
				if (text != null)
				{
					return text;
				}
			}
			float unscaledTime = Time.unscaledTime;
			if (!nextAvatarScanTime.TryGetValue(actorNumber, out var value2) || unscaledTime >= value2)
			{
				nextAvatarScanTime[actorNumber] = unscaledTime + 1f;
				foreach (PlayerAvatar item in SemiFunc.PlayerGetAll())
				{
					if ((Object)(object)item == (Object)null)
					{
						continue;
					}
					PhotonView component = ((Component)item).GetComponent<PhotonView>();
					if ((Object)(object)component != (Object)null && component.Owner != null && component.Owner.ActorNumber == actorNumber)
					{
						string text2 = BindIfAbsent(actorNumber, SemiFunc.PlayerGetSteamID(item));
						if (text2 != null)
						{
							return text2;
						}
						break;
					}
				}
			}
			if (((val != null) ? val.CustomProperties : null) != null && ((Dictionary<object, object>)(object)val.CustomProperties).TryGetValue((object)"steamId", out object value3) && value3 != null)
			{
				string text3 = BindIfAbsent(actorNumber, value3.ToString());
				if (text3 != null)
				{
					return text3;
				}
			}
			return null;
		}

		internal int FindActorNumber(string? steamId)
		{
			Room currentRoom = PhotonNetwork.CurrentRoom;
			if (currentRoom == null || string.IsNullOrEmpty(steamId))
			{
				return -1;
			}
			foreach (Player value in currentRoom.Players.Values)
			{
				if (Resolve(value.ActorNumber) == steamId)
				{
					return value.ActorNumber;
				}
			}
			return -1;
		}

		internal void Forget(int actorNumber)
		{
			actorToSteamId.Remove(actorNumber);
			nextAvatarScanTime.Remove(actorNumber);
		}

		internal void Clear()
		{
			actorToSteamId.Clear();
			nextAvatarScanTime.Clear();
		}
	}
	internal readonly struct PlayerValidationResult
	{
		internal readonly bool IsValid;

		internal readonly string Reason;

		internal PlayerValidationResult(bool isValid, string reason)
		{
			IsValid = isValid;
			Reason = reason;
		}
	}
	internal static class PlayerValidator
	{
		internal static PlayerValidationResult Validate(PlayerAvatar? player)
		{
			if ((Object)(object)player == (Object)null)
			{
				return new PlayerValidationResult(isValid: false, "Null player");
			}
			try
			{
				PhotonView component = ((Component)player).GetComponent<PhotonView>();
				if ((Object)(object)component == (Object)null)
				{
					return new PlayerValidationResult(isValid: false, "No PhotonView component");
				}
				if (component.Owner == null)
				{
					return new PlayerValidationResult(isValid: false, "PhotonView has no owner");
				}
				int actorNumber = component.Owner.ActorNumber;
				if (!PhotonNetwork.PlayerList.Any((Player p) => p.ActorNumber == actorNumber))
				{
					return new PlayerValidationResult(isValid: false, $"ActorNumber {actorNumber} not in PhotonNetwork.PlayerList");
				}
				string text = SemiFunc.PlayerGetSteamID(player);
				if (string.IsNullOrEmpty(text))
				{
					return new PlayerValidationResult(isValid: false, "No Steam ID");
				}
				if (!SteamUtils.TryParseValidSteamId(text, out var _))
				{
					return new PlayerValidationResult(isValid: false, "Invalid Steam ID: " + text);
				}
				return new PlayerValidationResult(isValid: true, "Valid");
			}
			catch (Exception ex)
			{
				return new PlayerValidationResult(isValid: false, "Exception: " + ex.Message);
			}
		}
	}
	internal static class PrivateVoiceChannel
	{
		private static readonly Regex RoomNamePattern = new Regex("\\Aspv1_[0-9a-f]{32}\\z", RegexOptions.Compiled);

		private static readonly HashSet<int> Members = new HashSet<int>();

		private static int[] memberActorsCache = Array.Empty<int>();

		private static bool localIsMember;

		internal static bool Active { get; private set; }

		internal static string RoomName { get; private set; } = string.Empty;

		internal static int Epoch { get; private set; }

		internal static bool LocalActive { get; private set; }

		internal static bool IsMemberActor(int actorNumber)
		{
			return Members.Contains(actorNumber);
		}

		internal static int[] MemberActors()
		{
			return memberActorsCache;
		}

		private static void RebuildMemberActorsCache()
		{
			int[] array = new int[Members.Count];
			Members.CopyTo(array);
			memberActorsCache = array;
		}

		internal static bool IsValidRoomName([NotNullWhen(true)] string? name)
		{
			if (name != null)
			{
				return RoomNamePattern.IsMatch(name);
			}
			return false;
		}

		internal static string GenerateRoomName()
		{
			byte[] array = new byte[16];
			using (RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create())
			{
				randomNumberGenerator.GetBytes(array);
			}
			StringBuilder stringBuilder = new StringBuilder(37);
			stringBuilder.Append("spv1_");
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2"));
			}
			return stringBuilder.ToString();
		}

		internal static string Fingerprint(string roomName)
		{
			if (string.IsNullOrEmpty(roomName))
			{
				return "------";
			}
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes("spv-fp:" + roomName));
			return $"{array[0]:x2}{array[1]:x2}{array[2]:x2}";
		}

		internal static void SetHost(bool active, string roomName, int epoch, int[] actors)
		{
			if (!active || !IsValidRoomName(roomName) || epoch < 0)
			{
				Clear();
				return;
			}
			Active = true;
			RoomName = roomName;
			Epoch = epoch;
			Members.Clear();
			foreach (int num in actors)
			{
				if (num > 0)
				{
					Members.Add(num);
				}
			}
			RebuildMemberActorsCache();
			Recompute();
		}

		internal static bool ApplyWire(string? activeArg, string? roomArg, string? epochArg, string? actorsCsv)
		{
			if (activeArg != "1")
			{
				Clear();
				return false;
			}
			if (!IsValidRoomName(roomArg))
			{
				Clear();
				return false;
			}
			if (!int.TryParse(epochArg, out var result) || result < 0)
			{
				Clear();
				return false;
			}
			List<int> list = new List<int>();
			string[] array = (actorsCsv ?? string.Empty).Split(',');
			foreach (string text in array)
			{
				if (text.Length != 0)
				{
					if (!int.TryParse(text, out var result2) || result2 <= 0)
					{
						Clear();
						return false;
					}
					list.Add(result2);
				}
			}
			if (list.Count == 0)
			{
				Clear();
				return false;
			}
			Active = true;
			RoomName = roomArg;
			Epoch = result;
			Members.Clear();
			foreach (int item in list)
			{
				Members.Add(item);
			}
			RebuildMemberActorsCache();
			Recompute();
			return true;
		}

		internal static void SetLocalMembership(bool isMember)
		{
			localIsMember = isMember;
			Recompute();
		}

		internal static void Clear()
		{
			Active = false;
			RoomName = string.Empty;
			Epoch = 0;
			Members.Clear();
			memberActorsCache = Array.Empty<int>();
			Recompute();
		}

		private static void Recompute()
		{
			LocalActive = Active && localIsMember;
		}
	}
	internal readonly struct IssuedToken
	{
		internal readonly string Token;

		internal readonly string SteamId;

		internal readonly string Name;

		internal IssuedToken(string token, string steamId, string name)
		{
			Token = token;
			SteamId = steamId;
			Name = name;
		}
	}
	internal static class PromotedTokenStore
	{
		private const int MaxNameChars = 24;

		private static Dictionary<string, IssuedToken>? tokens;

		private static bool suppressReload;

		private static Dictionary<string, IssuedToken> Tokens => tokens ?? (tokens = Parse(ModConfig.PromotedTokens.Value));

		internal static void InvalidateCache()
		{
			if (!suppressReload)
			{
				tokens = null;
			}
		}

		internal static bool Contains(string? token)
		{
			if (TokenGenerator.IsHexToken(token))
			{
				return Tokens.ContainsKey(token);
			}
			return false;
		}

		internal static IssuedToken? Find(string? token)
		{
			if (!TokenGenerator.IsHexToken(token) || !Tokens.TryGetValue(token, out var value))
			{
				return null;
			}
			return value;
		}

		internal static List<IssuedToken> Entries()
		{
			return Tokens.Values.OrderBy((IssuedToken t) => (t.Name.Length == 0) ? 1 : 0).ThenBy<IssuedToken, string>((IssuedToken t) => t.Name, StringComparer.OrdinalIgnoreCase).ThenBy<IssuedToken, string>((IssuedToken t) => t.Token, StringComparer.Ordinal)
				.ToList();
		}

		internal static void Add(string token, string? steamId, string? name)
		{
			if (TokenGenerator.IsHexToken(token))
			{
				Tokens[token] = new IssuedToken(token, SafeSteamId(steamId), SafeName(name));
				Save();
			}
		}

		internal static void Relabel(string token, string? steamId, string? name)
		{
			if (TokenGenerator.IsHexToken(token) && Tokens.TryGetValue(token, out var value) && value.SteamId.Length <= 0 && value.Name.Length <= 0)
			{
				string text = SafeSteamId(steamId);
				if (text.Length != 0)
				{
					Tokens[token] = new IssuedToken(token, text, SafeName(name));
					Save();
				}
			}
		}

		private static string SafeSteamId(string? steamId)
		{
			if (steamId == null || !ulong.TryParse(steamId, out var _))
			{
				return "";
			}
			return steamId;
		}

		private static string SafeName(string? name)
		{
			string text = (name ?? "").Trim();
			if (text.Length <= 24)
			{
				return text;
			}
			int num = 24;
			if (char.IsHighSurrogate(text[num - 1]))
			{
				num--;
			}
			return text.Substring(0, num);
		}

		internal static void Remove(string? token)
		{
			if (!string.IsNullOrEmpty(token) && Tokens.Remove(token))
			{
				Save();
			}
		}

		private static Dictionary<string, IssuedToken> Parse(string? csv)
		{
			Dictionary<string, IssuedToken> dictionary = new Dictionary<string, IssuedToken>();
			if (string.IsNullOrWhiteSpace(csv))
			{
				return dictionary;
			}
			string[] array = csv.Split(',');
			foreach (string text in array)
			{
				string text2 = text.Trim();
				if (text2.Length == 0)
				{
					continue;
				}
				int num = text2.IndexOf(':');
				if (num < 0)
				{
					if (TokenGenerator.IsHexToken(text2))
					{
						dictionary[text2] = new IssuedToken(text2, "", "");
					}
					continue;
				}
				string text3 = text2.Substring(0, num).Trim();
				if (TokenGenerator.IsHexToken(text3))
				{
					string text4 = text2.Substring(num + 1);
					int num2 = text4.IndexOf(':');
					string text5 = ((num2 < 0) ? text4 : text4.Substring(0, num2)).Trim();
					if (!ulong.TryParse(text5, out var _))
					{
						text5 = "";
					}
					string name = ((num2 < 0) ? "" : DecodeName(text4.Substring(num2 + 1).Trim()));
					dictionary[text3] = new IssuedToken(text3, text5, name);
				}
			}
			return dictionary;
		}

		private static string DecodeName(string base64)
		{
			if (base64.Length == 0)
			{
				return "";
			}
			try
			{
				return Encoding.UTF8.GetString(Convert.FromBase64String(base64));
			}
			catch
			{
				return "";
			}
		}

		private static string EncodeEntry(IssuedToken t)
		{
			if (t.SteamId.Length == 0 && t.Name.Length == 0)
			{
				return t.Token;
			}
			string text = ((t.Name.Length == 0) ? "" : Convert.ToBase64String(Encoding.UTF8.GetBytes(t.Name)));
			return t.Token + ":" + t.SteamId + ":" + text;
		}

		private static void Save()
		{
			string text = string.Join(",", Tokens.Values.Select(EncodeEntry).OrderBy<string, string>((string s) => s, StringComparer.Ordinal));
			if (ModConfig.PromotedTokens.Value == text)
			{
				return;
			}
			suppressReload = true;
			try
			{
				ModConfig.PromotedTokens.Value = text;
			}
			finally
			{
				suppressReload = false;
			}
		}
	}
	internal enum ModRole
	{
		None,
		ModUser,
		Moderator,
		Host
	}
	internal static class RoleResolver
	{
		internal static ModRole ResolveByPlayer(Player? player)
		{
			if (player == null)
			{
				return ModRole.None;
			}
			if (player.IsMasterClient)
			{
				return ModRole.Host;
			}
			return ResolveBySteamId(PlayerRegistry.Instance.Resolve(player.ActorNumber), isMaster: false);
		}

		internal static ModRole ResolveByAvatar(PlayerAvatar? avatar)
		{
			if ((Object)(object)avatar == (Object)null)
			{
				return ModRole.None;
			}
			PhotonView component = ((Component)avatar).GetComponent<PhotonView>();
			bool isMaster = (Object)(object)component != (Object)null && component.Owner != null && component.Owner.IsMasterClient;
			return ResolveBySteamId(SemiFunc.PlayerGetSteamID(avatar), isMaster);
		}

		internal static ModRole ResolveBySteamId(string? steamId, bool isMaster)
		{
			if (isMaster)
			{
				return ModRole.Host;
			}
			if (Moderators.Instance.IsModerator(steamId))
			{
				return ModRole.Moderator;
			}
			if (ModUsers.Instance.Contains(steamId))
			{
				return ModRole.ModUser;
			}
			return ModRole.None;
		}
	}
	internal static class SteamUtils
	{
		internal static void OpenProfile(string? steamIdString)
		{
			//IL_0010: 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)
			if (!TryParseValidSteamId(steamIdString, out var steamId))
			{
				return;
			}
			string text = $"https://steamcommunity.com/profiles/{steamId.Value}";
			try
			{
				if (SteamUtils.IsOverlayEnabled)
				{
					SteamFriends.OpenUserOverlay(steamId, "steamid");
				}
				else
				{
					Application.OpenURL(text);
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("Open Steam profile failed for " + steamIdString + ": " + ex.Message));
				try
				{
					Application.OpenURL(text);
				}
				catch
				{
				}
			}
		}

		internal static bool TryParseValidSteamId(string? steamIdString, out SteamId steamId)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_002d: Unknown result type (might be due to invalid IL or missing references)
			steamId = default(SteamId);
			if (string.IsNullOrEmpty(steamIdString) || !ulong.TryParse(steamIdString, out var result))
			{
				return false;
			}
			steamId = new SteamId
			{
				Value = result
			};
			return ((SteamId)(ref steamId)).IsValid;
		}
	}
	internal static class TokenGenerator
	{
		internal static string NewToken()
		{
			byte[] array = new byte[16];
			using RandomNumberGenerator randomNumberGenerator = RandomNumberGenerator.Create();
			randomNumberGenerator.GetBytes(array);
			StringBuilder stringBuilder = new StringBuilder(32);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2"));
			}
			return stringBuilder.ToString();
		}

		internal static bool IsHexToken(string? s)
		{
			if (s == null || s.Length != 32)
			{
				return false;
			}
			foreach (char c in s)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f'))
				{
					return false;
				}
			}
			return true;
		}
	}
	internal static class VoiceVolumes
	{
		internal const float Min = 0f;

		internal const float Max = 2f;

		private static readonly Dictionary<int, float> FactorByActor = new Dictionary<int, float>();

		internal static float FactorFor(int actorNumber)
		{
			if (!FactorByActor.TryGetValue(actorNumber, out var value))
			{
				return 1f;
			}
			return value;
		}

		internal static void Set(int actorNumber, float factor)
		{
			factor = ((factor < 0f) ? 0f : ((factor > 2f) ? 2f : factor));
			if (factor == 1f)
			{
				FactorByActor.Remove(actorNumber);
			}
			else
			{
				FactorByActor[actorNumber] = factor;
			}
		}

		internal static void Clear()
		{
			FactorByActor.Clear();
		}
	}
}
namespace SharePermissions.Patches
{
	internal static class AdminMenuGatePatch
	{
		private static bool applied;

		internal static void Init(Harmony harmony)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			if (applied || !AdminMenuBridge.IsAvailable)
			{
				return;
			}
			applied = true;
			try
			{
				HarmonyMethod val = new HarmonyMethod(typeof(AdminMenuGatePatch), "WidenHostGateTranspiler", (Type[])null);
				harmony.Patch((MethodBase)AdminMenuBridge.ToggleMenuMethod, (HarmonyMethod)null, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null);
				if (AdminMenuBridge.ChatMessageSendPrefixMethod != null)
				{
					harmony.Patch((MethodBase)AdminMenuBridge.ChatMessageSendPrefixMethod, (HarmonyMethod)null, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null);
				}
				else
				{
					Plugin.Logger.LogInfo((object)"Admin Menu chat gate not found - '!menu' stays host-only, hotkey unaffected");
				}
				harmony.Patch((MethodBase)AdminMenuBridge.UpdateClientsMethod, (HarmonyMethod)null, new HarmonyMethod(typeof(AdminMenuGatePatch), "UpdateClientsPostfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				ApplyActionPatches(harmony);
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("Admin Menu patching failed (" + ex.GetType().Name + ": " + ex.Message + ") - moderator admin-menu grant unavailable"));
			}
		}

		private static void ApplyActionPatches(Harmony harmony)
		{
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Expected O, but got Unknown
			AdminMenuActions.Resolve();
			if (AdminMenuActions.PlayerActionsAvailable)
			{
				Redirect(harmony, AdminMenuActions.KillPlayerMethod, "KillPrefix");
				Redirect(harmony, AdminMenuActions.HealPlayerMethod, "HealPrefix");
				Redirect(harmony, AdminMenuActions.RevivePlayerMethod, "RevivePrefix");
				Redirect(harmony, AdminMenuActions.GiveCrownMethod, "CrownPrefix");
				Redirect(harmony, AdminMenuActions.ReturnToTruckMethod, "TruckPrefix");
				Redirect(harmony, AdminMenuActions.TeleportToMethod, "TeleportToPrefix");
				Redirect(harmony, AdminMenuActions.SummonMethod, "SummonPrefix");
			}
			Redirect(harmony, AdminMenuActions.KickPlayerMethod, "KickPrefix");
			Redirect(harmony, AdminMenuActions.BanPlayerMethod, "BanPrefix");
			if (AdminMenuActions.SpawnAvailable)
			{
				Redirect(harmony, AdminMenuActions.SpawnItemMethod, "SpawnItemPrefix");
				Redirect(harmony, AdminMenuActions.SpawnValuableMethod, "SpawnValuablePrefix");
				Redirect(harmony, AdminMenuActions.SpawnEnemyMethod, "SpawnEnemyPrefix");
			}
			if (AdminMenuActions.MapAvailable)
			{
				Redirect(harmony, AdminMenuActions.ChangeLevelMethod, "ChangeLevelPrefix");
				Redirect(harmony, AdminMenuActions.SetMapEnabledMethod, "SetMapEnabledPrefix");
				Redirect(harmony, AdminMenuActions.DiscoverNextMethod, "DiscoverNextPrefix");
				Redirect(harmony, AdminMenuActions.CompleteExtractionMethod, "CompleteExtractionPrefix");
				if (AdminMenuActions.AddIntSliderMethod != null)
				{
					harmony.Patch((MethodBase)AdminMenuActions.AddIntSliderMethod, new HarmonyMethod(typeof(AdminMenuGatePatch), "AddIntSliderPrefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		private static void Redirect(Harmony harmony, MethodInfo? target, string prefixName)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			if (!(target == null))
			{
				harmony.Patch((MethodBase)target, new HarmonyMethod(typeof(AdminMenuGatePatch), prefixName, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static bool ShouldProxy()
		{
			try
			{
				return !SemiFunc.IsMasterClient() && ModerationActions.LocalCanModerate && HostCapabilities.AdminMenu;
			}
			catch
			{
				return false;
			}
		}

		private static bool Send(string verb, string arg = "")
		{
			try
			{
				CommandSender.Send("RamAction", new object[2] { verb, arg }, (ReceiverGroup)2);
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("Admin Menu action send failed (" + ex.GetType().Name + ": " + ex.Message + ")"));
			}
			return false;
		}

		private static string SteamIdOf(PlayerAvatar? target)
		{
			object obj;
			if (!((Object)(object)target == (Object)null))
			{
				obj = SemiFunc.PlayerGetSteamID(target);
				if (obj == null)
				{
					return "";
				}
			}
			else
			{
				obj = "";
			}
			return (string)obj;
		}

		private static bool PlayerVerb(string verb, PlayerAvatar avatar)
		{
			if (!ShouldProxy())
			{
				return true;
			}
			string text = SteamIdOf(avatar);
			if (text.Length == 0)
			{
				return false;
			}
			return Send(verb, text);
		}

		private static bool KillPrefix(PlayerAvatar avatar)
		{
			return PlayerVerb("kill", avatar);
		}

		private static bool HealPrefix(PlayerAvatar avatar)
		{
			return PlayerVerb("heal", avatar);
		}

		private static bool RevivePrefix(PlayerAvatar avatar)
		{
			return PlayerVerb("revive", avatar);
		}

		private static bool CrownPrefix(PlayerAvatar avatar)
		{
			return PlayerVerb("crown", avatar);
		}

		private static bool TruckPrefix(PlayerAvatar avatar)
		{
			return PlayerVerb("truck", avatar);
		}

		private static bool TeleportToPrefix(PlayerAvatar avatar)
		{
			return PlayerVerb("tpto", avatar);
		}

		private static bool SummonPrefix(PlayerAvatar avatar)
		{
			return PlayerVerb("summon", avatar);
		}

		private static bool KickBanRedirect(PlayerAvatar avatar, bool ban)
		{
			if (!ShouldProxy())
			{
				return true;
			}
			if ((Object)(object)avatar != (Object)null)
			{
				ModerationActions.KickPlayer(avatar, ban);
			}
			return false;
		}

		private static bool KickPrefix(PlayerAvatar avatar)
		{
			return KickBanRedirect(avatar, ban: false);
		}

		private static bool BanPrefix(PlayerAvatar avatar)
		{
			return KickBanRedirect(avatar, ban: true);
		}

		private static bool SpawnItemPrefix(Item item)
		{
			if (!ShouldProxy())
			{
				return true;
			}
			if (!((Object)(object)item == (Object)null))
			{
				return Send("item", ((Object)item).name.Replace("Item ", string.Empty));
			}
			return false;
		}

		private static bool SpawnValuablePrefix(PrefabRef valuable)
		{
			if (!ShouldProxy())
			{
				return true;
			}
			if (valuable != null)
			{
				return Send("valuable", ((PrefabRef<GameObject>)(object)valuable).PrefabName.Replace("Valuable ", string.Empty));
			}
			return false;
		}

		private static bool SpawnEnemyPrefix(string enemy)
		{
			if (!ShouldProxy())
			{
				return true;
			}
			return Send("enemy", enemy ?? "");
		}

		private static bool ChangeLevelPrefix(Level level)
		{
			if (!ShouldProxy())
			{
				return true;
			}
			if (!((Object)(object)level == (Object)null))
			{
				return Send("level", AdminMenuActions.LevelKey((Object)(object)level));
			}
			return false;
		}

		private static bool SetMapEnabledPrefix(Level level, bool enabled)
		{
			if (!ShouldProxy() || (Object)(object)level == (Object)null)
			{
				return true;
			}
			Send(enabled ? "mapon" : "mapoff", AdminMenuActions.LevelKey((Object)(object)level));
			return true;
		}

		private static bool DiscoverNextPrefix()
		{
			if (!ShouldProxy())
			{
				return true;
			}
			return Send("extdiscover");
		}

		private static bool CompleteExtractionPrefix()
		{
			if (!ShouldProxy())
			{
				return true;
			}
			return Send("extcomplete");
		}

		private static void AddIntSliderPrefix(string text, ref Action<int> action)
		{
			if (!ShouldProxy())
			{
				return;
			}
			if (text == "Current Level")
			{
				action = delegate(int v)
				{
					Send("levelsdone", v.ToString(CultureInfo.InvariantCulture));
				};
			}
			else if (text == "Money")
			{
				action = delegate(int v)
				{
					Send("money", v.ToString(CultureInfo.InvariantCulture));
				};
			}
		}

		internal static bool LocalMayOpen()
		{
			try
			{
				if (SemiFunc.IsMasterClientOrSingleplayer())
				{
					return true;
				}
				return ModerationActions.LocalCanModerate && HostCapabilities.AdminMenu;
			}
			catch
			{
				return false;
			}
		}

		private static IEnumerable<CodeInstruction> WidenHostGateTranspiler(IEnumerable<CodeInstruction> instructions, MethodBase __originalMethod)
		{
			MethodInfo methodInfo = AccessTools.Method(typeof(SemiFunc), "IsMasterClientOrSingleplayer", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(AdminMenuGatePatch), "LocalMayOpen", (Type[])null, (Type[])null);
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			int num = 0;
			if (methodInfo != null && methodInfo2 != null)
			{
				for (int i = 0; i < list.Count; i++)
				{
					if (CodeInstructionExtensions.Calls(list[i], methodInfo))
					{
						list[i].operand = methodInfo2;
						num++;
					}
				}
			}
			string text = __originalMethod?.DeclaringType?.Name + "." + __originalMethod?.Name;
			if (num == 0)
			{
				Plugin.Logger.LogWarning((object)("Admin Menu gate not found in " + text + " (API change?) - left unpatched"));
			}
			else
			{
				Plugin.Logger.LogInfo((object)string.Format("Admin Menu gate widened in {0} ({1} call site{2})", text, num, (num == 1) ? "" : "s"));
			}
			return list;
		}

		private static void UpdateClientsPostfix()
		{
			try
			{
				if (!SemiFunc.IsMasterClient() && ModerationActions.LocalCanModerate && HostCapabilities.AdminMenu)
				{
					string settingsJson = AdminMenuBridge.GetSettingsJson();
					if (!string.IsNullOrEmpty(settingsJson))
					{
						CommandSender.Send("RamSettings", new object[1] { settingsJson }, (ReceiverGroup)2);
					}
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("Admin Menu settings push failed (" + ex.GetType().Name + ": " + ex.Message + ")"));
			}
		}
	}
	[HarmonyPatch(typeof(SemiFunc), "UIMouseHover")]
	internal static class MenuModalGatePatch
	{
		private static readonly HashSet<MenuPage> ModalPages = new HashSet<MenuPage>();

		internal static void RegisterModalPage(MenuPage? page)
		{
			ModalPages.RemoveWhere((MenuPage p) => (Object)(object)p == (Object)null);
			if ((Object)(object)page != (Object)null)
			{
				ModalPages.Add(page);
			}
		}

		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static bool Prefix(MenuPage parentPage, ref bool __result)
		{
			MenuManager instance = MenuManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return true;
			}
			MenuPage currentMenuPage = instance.currentMenuPage;
			if ((Object)(object)currentMenuPage == (Object)null || !ModalPages.Contains(currentMenuPage))
			{
				return true;
			}
			if ((Object)(object)parentPage == (Object)(object)currentMenuPage)
			{
				return true;
			}
			if ((Object)(object)parentPage != (Object)null && parentPage.addedPageOnTop)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
	[HarmonyPatch(typeof(MenuPageLobby))]
	internal static class MenuPageLobbyPatch
	{
		private static readonly Dictionary<int, GameObject> GhostRows = new Dictionary<int, GameObject>();

		private static float nextSync;

		private const float SyncInterval = 0.5f;

		private const string XKickName = "SharePermissions_XKick";

		private const string UnknownPing = "-";

		private static readonly Color GhostHeadTone = new Color(1f, 1f, 1f, 0.5f);

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Update_Postfix(MenuPageLobby __instance)
		{
			if (Time.time < nextSync)
			{
				return;
			}
			nextSync = Time.time + 0.5f;
			foreach (int item in (from kv in GhostRows
				where (Object)(object)kv.Value == (Object)null
				select kv.Key).ToList())
			{
				GhostRows.Remove(item);
			}
			if (!ModerationActions.LocalCanModerate)
			{
				if (GhostRows.Count > 0)
				{
					ClearAll();
				}
				return;
			}
			if (!ModConfig.ShowGhostRows.Value)
			{
				if (GhostRows.Count > 0)
				{
					ClearAll();
				}
				return;
			}
			List<ModerationActions.GhostInfo> list = ModerationActions.GetGhosts().ToList();
			HashSet<int> ghostActors = new HashSet<int>(list.Select((ModerationActions.GhostInfo g) => g.Player.ActorNumber));
			foreach (int item2 in GhostRows.Keys.Where((int a) => !ghostActors.Contains(a)).ToList())
			{
				if ((Object)(object)GhostRows[item2] != (Object)null)
				{
					Object.Destroy((Object)(object)GhostRows[item2]);
				}
				GhostRows.Remove(item2);
			}
			int count = __instance.listObjects.Count;
			for (int num = 0; num < list.Count; num++)
			{
				ModerationActions.GhostInfo ghostInfo = list[num];
				if (!GhostRows.TryGetValue(ghostInfo.Player.ActorNumber, out GameObject value) || (Object)(object)value == (Object)null)
				{
					value = BuildGhostRow(ghostInfo.Player, __instance);
					if ((Object)(object)value == (Object)null)
					{
						continue;
					}
					GhostRows[ghostInfo.Player.ActorNumber] = value;
				}
				EnsureGhostKick(value, ghostInfo.Player);
				MenuPlayerListed component = value.GetComponent<MenuPlayerListed>();
				if ((Object)(object)component != (Object)null)
				{
					component.listSpot = count + num;
					SyncGhostPing(__instance, component, ghostInfo.UntrustedAvatar);
				}
			}
		}

		private static void EnsureGhostKick(GameObject row, Player ghost)
		{
			Transform val = null;
			Transform[] componentsInChildren = row.GetComponentsInChildren<Transform>(true);
			foreach (Transform val2 in componentsInChildren)
			{
				if (!(((Object)val2).name != "SharePermissions_XKick"))
				{
					val = val2;
					break;
				}
			}
			bool flag = ModerationActions.ShouldShowKickForActor(ghost);
			if (flag == ((Object)(object)val != (Object)null))
			{
				return;
			}
			if (!flag)
			{
				((Object)val).name = "SharePermissions_XKick_discarded";
				Object.Destroy((Object)(object)((Component)val).gameObject);
				return;
			}
			MenuButtonKick componentInChildren = row.GetComponentInChildren<MenuButtonKick>(true);
			if (!((Object)(object)componentInChildren == (Object)null))
			{
				Player captured = ghost;
				NativeKickButton.CreateX(((Component)componentInChildren).gameObject, delegate
				{
					ModerationActions.HandleGhostKick(captured);
				});
			}
		}

		[HarmonyPatch("OnDestroy")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void OnDestroy_Postfix()
		{
			ClearAll();
		}

		private static void ClearAll()
		{
			foreach (GameObject value in GhostRows.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
			}
			GhostRows.Clear();
			nextSync = 0f;
			VoiceChatPatch.ClearActorMap();
		}

		private static GameObject? BuildGhostRow(Player ghost, MenuPageLobby lobby)
		{
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			MenuPlayerListed val = ((IEnumerable<MenuPlayerListed>)lobby.menuPlayerListedList).FirstOrDefault((Func<MenuPlayerListed, bool>)((MenuPlayerListed r) => (Object)(object)r != (Object)null));
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, (Transform)(object)lobby.playerListTransform);
			((Object)val2).name = $"SharePermissions_GhostRow_{ghost.ActorNumber}";
			Transform[] componentsInChildren = val2.GetComponentsInChildren<Transform>(true);
			foreach (Transform val3 in componentsInChildren)
			{
				if (!(((Object)val3).name != "SharePermissions_XKick"))
				{
					((Object)val3).name = "SharePermissions_XKick_discarded";
					Object.Destroy((Object)(object)((Component)val3).gameObject);
				}
			}
			MenuPlayerListed component = val2.GetComponent<MenuPlayerListed>();
			component.playerAvatar = null;
			if ((Object)(object)component.playerName != (Object)null)
			{
				((TMP_Text)component.playerName).richText = true;
				((TMP_Text)component.playerName).text = "<color=#FFAA00>[GHOST]</color> " + MenuUiHelpers.SanitizePlayerName(ghost.NickName, $"Unknown_{ghost.ActorNumber}");
				((Graphic)component.playerName).color = GhostRowDriver.IdleNameColor;
			}
			if ((Object)(object)component.playerHead != (Object)null)
			{
				StyleGhostHead(component.playerHead);
				CompleteHeadStart(component.playerHead);
			}
			if ((Object)(object)component.leftCrown != (Object)null)
			{
				component.leftCrown.SetActive(false);
			}
			if ((Object)(object)component.rightCrown != (Object)null)
			{
				component.rightCrown.SetActive(false);
			}
			MenuPlayerListedSteam componentInChildren = val2.GetComponentInChildren<MenuPlayerListedSteam>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((Component)componentInChildren).gameObject.SetActive(false);
			}
			MenuButtonKick componentInChildren2 = val2.GetComponentInChildren<MenuButtonKick>(true);
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				((Component)componentInChildren2).gameObject.SetActive(false);
			}
			val2.AddComponent<GhostRowDriver>().Initialize(ghost.ActorNumber);
			return val2;
		}

		private static void SyncGhostPing(MenuPageLobby lobby, MenuPlayerListed mpl, PlayerAvatar? untrustedAvatar)
		{
			if ((Object)(object)mpl.pingText == (Object)null)
			{
				return;
			}
			if ((Object)(object)untrustedAvatar == (Object)null)
			{
				SetUnknownPing(mpl.pingText);
				return;
			}
			try
			{
				NativeSetPingText(lobby, mpl.pingText, untrustedAvatar.playerPing);
			}
			catch
			{
				SetUnknownPing(mpl.pingText);
			}
		}

		private static void SetUnknownPing(TextMeshProUGUI text)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			((TMP_Text)text).text = "-";
			((Graphic)text).color = new Color(0.5f, 0.5f, 0.5f);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void NativeSetPingText(MenuPageLobby lobby, TextMeshProUGUI text, int ping)
		{
			lobby.SetPingText(text, ping);
		}

		private static void StyleGhostHead(MenuPlayerHead head)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			((Behaviour)head).enabled = false;
			head.focusPoint = new GameObject("GhostFocusSink", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			head.myFocusPoint = new GameObject("GhostFocusSink", new Type[1] { typeof(RectTransform) }).GetComponent<RectTransform>();
			((Transform)head.focusPoint).SetParent(((Component)head).transform, false);
			((Transform)head.myFocusPoint).SetParent(((Component)head).transform, false);
			RawImage[] componentsInChildren = ((Component)head).GetComponentsInChildren<RawImage>(true);
			foreach (RawImage val in componentsInChildren)
			{
				string name = ((Object)val).name;
				if ((name == "Arena Crown" || name == "Steam Icon") ? true : false)
				{
					((Component)val).gameObject.SetActive(false);
				}
				else if (!IsUnderEyes(((Component)val).transform))
				{
					((Graphic)val).color = GhostHeadTone;
				}
			}
		}

		private static bool IsUnderEyes(Transform t)
		{
			Transform val = t;
			while ((Object)(object)val != (Object)null)
			{
				if (((Object)val).name == "Eyes")
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}

		private static void CompleteHeadStart(MenuPlayerHead head)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)MenuManager.instance != (Object)null)
			{
				MenuManager.instance.PlayerHeadAdd(head);
			}
			if ((Object)(object)head.muteIconTransform != (Object)null)
			{
				((Transform)head.muteIconTransform).localScale = Vector3.zero;
			}
		}
	}
	[HarmonyPatch(typeof(MenuPlayerListed))]
	internal static class MenuPlayerListedPatch
	{
		private sealed class RowMarker : MonoBehaviour
		{
			internal bool modColorInit;

			internal Color modNameColor;

			internal NameColorCache colorCache;

			internal MenuButtonKick? nativeKick;

			internal GameObject? kickClone;
		}

		private const float IdleFactor = 0.45f;

		private static readonly Color NameDead = new Color(0.1f, 0.1f, 0.1f);

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Update_Postfix(MenuPlayerListed __instance)
		{
			//IL_005c: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)__instance.playerAvatar == (Object)null || (Object)(object)__instance.playerName == (Object)null)
			{
				return;
			}
			if (ModConfig.ShowModeratorNameColor.Value)
			{
				RowMarker rowMarker = ((Component)__instance).GetComponent<RowMarker>() ?? ((Component)__instance).gameObject.AddComponent<RowMarker>();
				Color? val = rowMarker.colorCache.Get(__instance.playerAvatar);
				if (val.HasValue)
				{
					Color valueOrDefault = val.GetValueOrDefault();
					ApplyNameColor(__instance, rowMarker, valueOrDefault);
				}
			}
			EnsureKickButton(__instance);
		}

		private static void ApplyNameColor(MenuPlayerListed row, RowMarker marker, Color tint)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: 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_0067: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			PlayerAvatar playerAvatar = row.playerAvatar;
			Color val = (((Object)(object)playerAvatar.playerDeathHead != (Object)null && playerAvatar.playerDeathHead.spectated) ? NameDead : ((!playerAvatar.voiceChatFetched || !((Object)(object)playerAvatar.voiceChat != (Object)null) || !playerAvatar.voiceChat.isTalking) ? NameColors.Dimmed(tint, 0.45f) : tint));
			if (!marker.modColorInit)
			{
				marker.modNameColor = val;
				marker.modColorInit = true;
			}
			else
			{
				marker.modNameColor = Color.Lerp(marker.modNameColor, val, Time.deltaTime * 10f);
			}
			((Graphic)row.playerName).color = marker.modNameColor;
		}

		private static void EnsureKickButton(MenuPlayerListed row)
		{
			RowMarker rowMarker = ((Component)row).GetComponent<RowMarker>() ?? ((Component)row).gameObject.AddComponent<RowMarker>();
			if ((Object)(object)rowMarker.nativeKick == (Object)null)
			{
				rowMarker.nativeKick = ((Component)row).GetComponentInChildren<MenuButtonKick>(true);
				if ((Object)(object)rowMarker.nativeKick == (Object)null)
				{
					return;
				}
				((Component)rowMarker.nativeKick).gameObject.SetActive(false);
			}
			bool flag = ModerationActions.ShouldShowKickFor(row.playerAvatar);
			bool flag2 = (Object)(object)rowMarker.kickClone != (Object)null;
			if (flag == flag2)
			{
				return;
			}
			if (flag)
			{
				PlayerAvatar avatar = row.playerAvatar;
				rowMarker.kickClone = NativeKickButton.CreateX(((Component)rowMarker.nativeKick).gameObject, delegate
				{
					ModerationActions.HandlePlayerKick(avatar);
				});
			}
			else if ((Object)(object)rowMarker.kickClone != (Object)null)
			{
				Object.Destroy((Object)(object)rowMarker.kickClone);
				rowMarker.kickClone = null;
			}
		}
	}
	[HarmonyPatch(typeof(MenuSliderPlayerMicGain))]
	internal static class MenuSliderPlayerMicGainPatch
	{
		private sealed class RowMarker : MonoBehaviour
		{
			internal MenuButtonKick? nativeKick;

			internal bool nativeKickWasActive;

			internal GameObject? kickClone;

			internal NameColorCache colorCache;

			internal bool tintApplied;

			internal Color appliedTint;

			internal Color originalColor;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Update_Postfix(MenuSliderPlayerMicGain __instance)
		{
			if (!IsEscPageRow(__instance))
			{
				return;
			}
			PlayerAvatar playerAvatar = __instance.playerAvatar;
			if ((Object)(object)playerAvatar == (Object)null)
			{
				RowMarker component = ((Component)__instance).GetComponent<RowMarker>();
				if ((Object)(object)component != (Object)null)
				{
					TeardownRow(__instance, component);
				}
			}
			else
			{
				RowMarker marker = ((Component)__instance).GetComponent<RowMarker>() ?? ((Component)__instance).gameObject.AddComponent<RowMarker>();
				EnsureKickButton(__instance, marker, playerAvatar);
				ApplyNameColor(__instance, marker, playerAvatar);
			}
		}

		private static void RestoreNativeKick(RowMarker marker)
		{
			if ((Object)(object)marker.kickClone != (Object)null)
			{
				Object.Destroy((Object)(object)marker.kickClone);
				marker.kickClone = null;
			}
			if ((Object)(object)marker.nativeKick != (Object)null)
			{
				((Component)marker.nativeKick).gameObject.SetActive(marker.nativeKickWasActive);
				marker.nativeKick = null;
			}
		}

		private static void TeardownRow(MenuSliderPlayerMicGain row, RowMarker marker)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			RestoreNativeKick(marker);
			if (marker.tintApplied)
			{
				TextMeshProUGUI val = (((Object)(object)row.menuSlider != (Object)null) ? row.menuSlider.elementNameText : null);
				if ((Object)(object)val != (Object)null)
				{
					((Graphic)val).color = marker.originalColor;
				}
				marker.tintApplied = false;
			}
		}

		private static bool IsEscPageRow(MenuSliderPlayerMicGain row)
		{
			return (Object)(object)((Component)row).GetComponentInParent<MenuPageEsc>() != (Object)null;
		}

		private static void EnsureKickButton(MenuSliderPlayerMicGain row, RowMarker marker, PlayerAvatar avatar)
		{
			if ((Object)(object)marker.nativeKick == (Object)null)
			{
				marker.nativeKick = ((Component)row).GetComponentInChildren<MenuButtonKick>(true);
				if ((Object)(object)marker.nativeKick == (Object)null)
				{
					return;
				}
				marker.nativeKickWasActive = ((Component)marker.nativeKick).gameObject.activeSelf;
				((Component)marker.nativeKick).gameObject.SetActive(false);
			}
			bool flag = ModerationActions.ShouldShowKickFor(avatar);
			bool flag2 = (Object)(object)marker.kickClone != (Object)null;
			if (flag == flag2)
			{
				return;
			}
			if (flag)
			{
				marker.kickClone = NativeKickButton.CreateX(((Component)marker.nativeKick).gameObject, delegate
				{
					ModerationActions.HandlePlayerKick(avatar);
				});
			}
			else if ((Object)(object)marker.kickClone != (Object)null)
			{
				Object.Destroy((Object)(object)marker.kickClone);
				marker.kickClone = null;
			}
		}

		private static void ApplyNameColor(MenuSliderPlayerMicGain row, RowMarker marker, PlayerAvatar avatar)
		{
			//IL_0056: 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_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			TextMeshProUGUI val = (((Object)(object)row.menuSlider != (Object)null) ? row.menuSlider.elementNameText : null);
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			Color? val2 = (ModConfig.ShowModeratorNameColor.Value ? marker.colorCache.Get(avatar) : ((Color?)null));
			if (val2.HasValue)
			{
				Color valueOrDefault = val2.GetValueOrDefault();
				if (!marker.tintApplied || !(marker.appliedTint == valueOrDefault))
				{
					if (!marker.tintApplied)
					{
						marker.originalColor = ((Graphic)val).color;
					}
					marker.tintApplied = true;
					marker.appliedTint = valueOrDefault;
					((Graphic)val).color = valueOrDefault;
				}
			}
			else if (marker.tintApplied)
			{
				marker.tintApplied = false;
				((Graphic)val).color = marker.originalColor;
			}
		}
	}
	[HarmonyPatch(typeof(NetworkConnect))]
	internal static class NetworkConnectPatch
	{
		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Start_Postfix()
		{
			CommandReceiver.Init();
		}

		[HarmonyPatch("OnJoinedRoom")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void OnJoinedRoom_Postfix()
		{
			Plugin.Logger.LogInfo((object)"Joined room");
			SessionState.Reset("joined room");
			NotificationCenter.ArmSession();
			if (!SemiFunc.IsMasterClient())
			{
				JoinAnnouncer.Arm();
			}
		}

		[HarmonyPatch("OnDisconnected")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void OnDisconnected_Postfix()
		{
			SessionState.Reset("disconnected during connect flow");
		}
	}
	[HarmonyPatch(typeof(NetworkManager))]
	internal static class NetworkManagerPatch
	{
		[HarmonyPatch("OnDisconnected")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void OnDisconnected_Postfix()
		{
			SessionState.Reset("left room");
		}

		[HarmonyPatch("OnPlayerLeftRoom")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void OnPlayerLeftRoom_Postfix(Player otherPlayer)
		{
			if (otherPlayer == null)
			{
				return;
			}
			string text = PlayerRegistry.Instance.TryGetSteamId(otherPlayer.ActorNumber);
			if (!string.IsNullOrEmpty(text) && !StillPresentUnderAnotherActor(text, otherPlayer.ActorNumber))
			{
				if (Moderators.Instance.IsModerator(text))
				{
					Moderators.Instance.RemoveModerator(text);
					Plugin.Logger.LogInfo((object)("Player " + otherPlayer.NickName + " (" + text + ") left - removed moderator status"));
				}
				ModUsers.Instance.Remove(text);
			}
			RpcFloodMonitor.Instance.Forget(otherPlayer.ActorNumber);
			PlayerRegistry.Instance.Forget(otherPlayer.ActorNumber);
		}

		private static bool StillPresentUnderAnotherActor(string steamId, int leavingActor)
		{
			Room currentRoom = PhotonNetwork.CurrentRoom;
			if (currentRoom == null)
			{
				return false;
			}
			foreach (Player value in currentRoom.Players.Values)
			{
				if (value != null && value.ActorNumber != leavingActor && PlayerRegistry.Instance.TryGetSteamId(value.ActorNumber) == steamId)
				{
					Plugin.Logger.LogWarning((object)$"Actor {leavingActor} left holding Steam ID {steamId}, still bound to live actor {value.ActorNumber} - keeping roles");
					return true;
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerAvatarVisuals))]
	internal static class PlayerAvatarIndicatorPatch
	{
		private sealed class MarkerState
		{
			internal Transform? Marker;

			internal ModRole BuiltTier;
		}

		private const float RefreshInterval = 0.2f;

		private static readonly Dictionary<PlayerAvatarVisuals, MarkerState> States = new Dictionary<PlayerAvatarVisuals, MarkerState>();

		private static readonly List<PlayerAvatarVisuals> DeadKeys = new List<PlayerAvatarVisuals>();

		private static readonly List<PlayerAvatarVisuals> KeySnapshot = new List<PlayerAvatarVisuals>();

		private static float nextRefreshTime;

		private static int refreshFrame = -1;

		internal static void Init()
		{
			Moderators.Instance.Changed += RefreshAllIndicators;
			ModUsers.Instance.Changed += RefreshAllIndicators;
		}

		[HarmonyPatch("Start")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Start_Postfix(PlayerAvatarVisuals __instance)
		{
			if (!__instance.isMenuAvatar && (!((Object)(object)__instance.playerAvatar != (Object)null) || !__instance.playerAvatar.isLocal) && !((Object)(object)__instance.attachPointTopHeadMiddle == (Object)null))
			{
				PruneDeadKeys();
				Refresh(__instance);
			}
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Update_Postfix(PlayerAvatarVisuals __instance)
		{
			if (!__instance.isMenuAvatar && !((Object)(object)__instance.playerAvatar == (Object)null) && !__instance.playerAvatar.isLocal)
			{
				if (Time.time >= nextRefreshTime)
				{
					nextRefreshTime = Time.time + 0.2f;
					refreshFrame = Time.frameCount;
				}
				if (Time.frameCount == refreshFrame)
				{
					Refresh(__instance);
				}
			}
		}

		private static Transform? BuildMarker(Transform attach, ModRole tier)
		{
			return (Transform?)(tier switch
			{
				ModRole.Host => HeadMarkers.BuildCrown(attach), 
				ModRole.Moderator => HeadMarkers.BuildGem(attach), 
				ModRole.ModUser => HeadMarkers.BuildDiamond(attach), 
				_ => null, 
			});
		}

		private static void Refresh(PlayerAvatarVisuals visuals)
		{
			if ((Object)(object)visuals == (Object)null || (Object)(object)visuals.attachPointTopHeadMiddle == (Object)null)
			{
				return;
			}
			if (!States.TryGetValue(visuals, out MarkerState value))
			{
				value = new MarkerState
				{
					BuiltTier = ModRole.None
				};
				States[visuals] = value;
			}
			ModRole modRole = RoleResolver.ResolveByAvatar(visuals.playerAvatar);
			if (modRole != value.BuiltTier)
			{
				if ((Object)(object)value.Marker != (Object)null)
				{
					((Component)value.Marker).GetComponent<HeadMarkerComponent>()?.DestroyOwnedMaterials();
					Object.Destroy((Object)(object)((Component)value.Marker).gameObject);
				}
				value.Marker = BuildMarker(visuals.attachPointTopHeadMiddle, modRole);
				value.BuiltTier = modRole;
			}
			bool flag = ModConfig.ShowHeadMarkers.Value && modRole != ModRole.None && (SemiFunc.RunIsLobbyMenu() || SemiFunc.RunIsLobby());
			if ((Object)(object)value.Marker != (Object)null && ((Component)value.Marker).gameObject.activeSelf != flag)
			{
				((Component)value.Marker).gameObject.SetActive(flag);
			}
		}

		private static void PruneDeadKeys()
		{
			DeadKeys.Clear();
			foreach (KeyValuePair<PlayerAvatarVisuals, MarkerState> state in States)
			{
				if ((Object)(object)state.Key == (Object)null)
				{
					DeadKeys.Add(state.Key);
				}
			}
			foreach (PlayerAvatarVisuals deadKey in DeadKeys)
			{
				States.Remove(deadKey);
			}
		}

		internal static void RefreshAllIndicators()
		{
			PruneDeadKeys();
			KeySnapshot.Clear();
			KeySnapshot.AddRange(States.Keys);
			foreach (PlayerAvatarVisuals item in KeySnapshot)
			{
				Refresh(item);
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal static class RecorderTransmitPatch
	{
		internal static bool Suppress;

		[HarmonyPrefix]
		[HarmonyWrapSafe]
		[HarmonyPriority(0)]
		private static void TransmitEnabled_Prefix(Recorder __instance, ref bool value)
		{
			if (Suppress && !IsPrivateRecorder(__instance))
			{
				value = false;
			}
		}

		private static bool IsPrivateRecorder(Recorder recorder)
		{
			if ((Object)(object)PrivateVoiceClient.Instance != (Object)null)
			{
				return PrivateVoiceClient.Instance.PrivateRecorder == recorder;
			}
			return false;
		}

		internal static void ForceOff(Recorder recorder)
		{
			if ((Object)(object)recorder != (Object)null && recorder.TransmitEnabled)
			{
				recorder.TransmitEnabled = false;
			}
		}
	}
	[HarmonyPatch(typeof(LoadBalancingClient), "OnEvent", new Type[] { typeof(EventData) })]
	internal static class RpcFloodPatch
	{
		private const byte RpcEventCode = 200;

		private static readonly object RpcIndexKey = (byte)5;

		private static readonly object RpcNameKey = (byte)3;

		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static bool OnEvent_Prefix(LoadBalancingClient __instance, EventData photonEvent)
		{
			if (photonEvent.Code != 200)
			{
				return true;
			}
			FloodMode value = ModConfig.Mode.Value;
			if (value == FloodMode.Off)
			{
				return true;
			}
			if (!SemiFunc.RunIsLobbyMenu())
			{
				return true;
			}
			if (__instance != PhotonNetwork.NetworkingClient)
			{
				return true;
			}
			int sender = photonEvent.Sender;
			Room currentRoom = PhotonNetwork.CurrentRoom;
			Player val = ((currentRoom != null) ? currentRoom.GetPlayer(sender, false) : null);
			if (val == null || val.IsLocal || val.IsMasterClient)
			{
				return true;
			}
			if (AuthorizedActors.IsModeratorActor(sender))
			{
				return true;
			}
			string attackerSteamId = PlayerRegistry.Instance.Resolve(sender);
			int num = ((__instance.LoadBalancingPeer != null) ? ((PhotonPeer)__instance.LoadBalancingPeer).ByteCountCurrentDispatch : 0);
			string rpcName = TryGetRpcName(photonEvent.CustomData);
			RpcFloodMonitor.RecordResult recordResult = RpcFloodMonitor.Instance.Record(sender, rpcName, num);
			int value2 = ModConfig.RpcFloodPerSecond.Value;
			int num2 = Math.Max(ModConfig.AutoKickRpcPerSecond.Value, value2);
			bool flag = recordResult.Total > value2;
			bool flag2 = recordResult.Total > num2;
			bool flag3 = num > ModConfig.RpcMaxBytes.Value;
			if (flag || flag3)
			{
				FloodKeepAlive.OnFloodPacket(__instance, flag3);
			}
			bool flag4 = flag2 || flag3;
			if (value == FloodMode.LogOnly)
			{
				if (recordResult.NewPeakRate || recordResult.NewPeakBytes)
				{
					string text = (flag4 ? " (EXCEEDS KICK THRESHOLD - would auto-kick in Kick mode)" : (flag ? " (over drop limit - would drop, not kick)" : ""));
					Plugin.Logger.LogMessage((object)$"[RPC-observe] {val.NickName} (actor {sender}) peak {RpcFloodMonitor.Instance.PeakRate(sender)}/s, peak {RpcFloodMonitor.Instance.PeakBytes(sender)}B; top: {RpcFloodMonitor.Instance.TopNames(sender, 3)}{text}");
				}
				return true;
			}
			if (!flag && !flag3)
			{
				return true;
			}
			if (flag4 && RpcFloodMonitor.Instance.MarkHandled(sender))
			{
				string reason = ((flag2 && flag3) ? $"{recordResult.Total}/s and {num}B" : (flag2 ? $"{recordResult.Total}/s (kick limit {num2})" : $"{num}B (limit {ModConfig.RpcMaxBytes.Value})"));
				if (HandleFlood(sender, val, attackerSteamId, reason))
				{
					FloodKeepAlive.FlushNow(__instance);
				}
			}
			return false;
		}

		private static bool HandleFlood(int actorNumber, Player senderPlayer, string? attackerSteamId, string reason)
		{
			string text = senderPlayer.NickName ?? "<unknown>";
			if (SemiFunc.IsMasterClient())
			{
				GameActions.KickByActorNumber(actorNumber, ban: false);
				AuditEvents.RpcFloodAutoKick(text, actorNumber, attackerSteamId, reason);
				Plugin.Logger.LogWarning((object)$"RPC flood from {text} (actor {actorNumber}) - auto-kicked ({reason})");
				return true;
			}
			if (Moderators.Instance.IsModerator(ModerationActions.LocalSteamId))
			{
				if (!string.IsNullOrEmpty(attackerSteamId) && Moderators.Instance.IsModerator(attackerSteamId))
				{
					Plugin.Logger.LogWarning((object)$"RPC flood from moderator {text} (actor {actorNumber}) - not requesting kick ({reason})");
					return false;
				}
				CommandSender.Send("KickGhostPlayer", new object[3]
				{
					$"{actorNumber}",
					"kick",
					"flood"
				}, (ReceiverGroup)2);
				Plugin.Logger.LogWarning((object)$"RPC flood from {text} (actor {actorNumber}) - requested host to kick attacker ({reason})");
				return true;
			}
			Plugin.Logger.LogWarning((object)$"RPC flood from {text} (actor {actorNumber}) - dropping their RPCs ({reason})");
			return false;
		}

		private static string TryGetRpcName(object? customData)
		{
			try
			{
				Hashtable val = (Hashtable)((customData is Hashtable) ? customData : null);
				if (val == null)
				{
					return "?";
				}
				if (((Dictionary<object, object>)(object)val).TryGetValue(RpcIndexKey, out object value) && value is short num)
				{
					List<string> list = PhotonNetwork.PhotonServerSettings?.RpcList;
					if (list != null && num >= 0 && num < list.Count)
					{
						return list[num];
					}
					return "?";
				}
				if (((Dictionary<object, object>)(object)val).TryGetValue(RpcNameKey, out object value2) && value2 is string result)
				{
					return result;
				}
				return "?";
			}
			catch
			{
				return "?";
			}
		}
	}
	[HarmonyPatch(typeof(MenuPageLobby), "ButtonStart")]
	internal static class StartButtonPatch
	{
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static bool ButtonStart_Prefix()
		{
			if (!SemiFunc.IsMultiplayer())
			{
				return true;
			}
			if ((Object)(object)MenuPageLobby.instance != (Object)null && MenuPageLobby.instance.joiningPlayer)
			{
				return true;
			}
			if (StartCountdown.Active)
			{
				try
				{
					StartCountdown.RequestCancelFromUi();
				}
				catch (Exception arg)
				{
					Plugin.Logger.LogError((object)$"Countdown cancel from Start button failed: {arg}");
				}
				return false;
			}
			if (!SemiFunc.IsMasterClient())
			{
				try
				{
					ModerationActions.StartGame();
				}
				catch (Exception arg2)
				{
					Plugin.Logger.LogError((object)$"Moderator start request failed: {arg2}");
				}
				return false;
			}
			if (ModConfig.StartCountdownSeconds.Value <= 0)
			{
				return true;
			}
			StartCountdown.BeginHostAuthoritative(ModConfig.StartCountdownSeconds.Value);
			return false;
		}
	}
	[HarmonyPatch(typeof(MenuButton), "OnSelect")]
	internal static class StartCancelClickPatch
	{
		[HarmonyPrefix]
		[HarmonyWrapSafe]
		private static bool OnSelect_Prefix(MenuButton __instance)
		{
			if (!StartCountdown.Active)
			{
				return true;
			}
			MenuPageLobby instance = MenuPageLobby.instance;
			if ((Object)(object)instance == (Object)null || (Object)(object)__instance != (Object)(object)instance.startButton)
			{
				return true;
			}
			if (!ModerationActions.LocalCanModerate)
			{
				return true;
			}
			try
			{
				StartCountdown.RequestCancelFromUi();
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Countdown cancel from Start button failed: {arg}");
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(PlayerVoiceChat), "Update")]
	internal static class VoiceChatPatch
	{
		internal static readonly Dictionary<int, PlayerVoiceChat> ByActor = new Dictionary<int, PlayerVoiceChat>();

		private static readonly float[] SampleBuf = new float[1024];

		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Update_Postfix(PlayerVoiceChat __instance)
		{
			PhotonView component = ((Component)__instance).GetComponent<PhotonView>();
			if (!((Object)(object)component == (Object)null) && component.Owner != null)
			{
				int actorNumber = component.Owner.ActorNumber;
				ByActor[actorNumber] = __instance;
				float num = VoiceVolumes.FactorFor(actorNumber);
				if (PrivateVoiceChannel.LocalActive && !PrivateVoiceChannel.IsMemberActor(actorNumber))
				{
					num = 0f;
				}
				if (num != 1f)
				{
					ApplyVolumeFactor(__instance, num);
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ApplyVolumeFactor(PlayerVoiceChat pvc, float factor)
		{
			if ((Object)(object)pvc.lowPassLogic != (Object)null)
			{
				AudioLowPassLogic lowPassLogic = pvc.lowPassLogic;
				lowPassLogic.Volume *= factor;
			}
			if ((Object)(object)pvc.lowPassLogicTTS != (Object)null && (Object)(object)pvc.playerAvatar != (Object)null)
			{
				AudioLowPassLogic lowPassLogicTTS = pvc.lowPassLogicTTS;
				lowPassLogicTTS.Volume *= factor;
			}
		}

		internal static float AmplitudeFor(int actorNumber)
		{
			if (!ByActor.TryGetValue(actorNumber, out PlayerVoiceChat value) || (Object)(object)value == (Object)null)
			{
				return 0f;
			}
			try
			{
				AudioSource audioSource = value.audioSource;
				if ((Object)(object)audioSource == (Object)null || (Object)(object)audioSource.clip == (Object)null || !audioSource.isPlaying)
				{
					return 0f;
				}
				audioSource.clip.GetData(SampleBuf, audioSource.timeSamples);
				float num = 0f;
				for (int i = 0; i < SampleBuf.Length; i++)
				{
					num += Mathf.Abs(SampleBuf[i]);
				}
				return num / (float)SampleBuf.Length;
			}
			catch
			{
				return 0f;
			}
		}

		internal static void ClearActorMap()
		{
			ByActor.Clear();
		}
	}
	[HarmonyPatch(typeof(WorldSpaceUIPlayerName))]
	internal static class WorldSpaceUIPlayerNamePatch
	{
		private sealed class TintMarker : MonoBehaviour
		{
			internal NameColorCache colorCache;
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		[HarmonyWrapSafe]
		private static void Update_Postfix(WorldSpaceUIPlayerName __instance)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: 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_0090: Unknown result type (might be due to invalid IL or missing references)
			if (ModConfig.ShowModeratorNameColor.Value && !((Object)(object)__instance.text == (Object)null) && !((Object)(object)__instance.playerAvatar == (Object)null))
			{
				TintMarker tintMarker = ((Component)__instance).GetComponent<TintMarker>() ?? ((Component)__instance).gameObject.AddComponent<TintMarker>();
				Color? val = tintMarker.colorCache.Get(__instance.playerAvatar);
				if (val.HasValue)
				{
					Color valueOrDefault = val.GetValueOrDefault();
					Color color = ((Graphic)__instance.text).color;
					((Graphic)__instance.text).color = new Color(valueOrDefault.r, valueOrDefault.g, valueOrDefault.b, color.a);
				}
			}
		}
	}
}
namespace SharePermissions.Net
{
	internal static class AuditSync
	{
		private static bool initialized;

		internal static void Init()
		{
			if (!initialized)
			{
				initialized = true;
				AuditLog.EntryWritten += OnEntryWritten;
			}
		}

		private static void OnEntryWritten(string entry, string kind)
		{
			if (SemiFunc.IsMasterClient())
			{
				int[] array = ModeratorActors();
				if (array.Length != 0)
				{
					object[] args = ((!(kind == "none")) ? new object[2] { entry, kind } : new object[1] { entry });
					CommandSender.SendToActors("AuditSync", args, array);
				}
			}
		}

		internal static void SendBacklogTo(int actorNumber)
		{
			if (!SemiFunc.IsMasterClient())
			{
				return;
			}
			int[] actors = new int[1] { actorNumber };
			foreach (string entry in AuditLog.GetEntries())
			{
				CommandSender.SendToActors("AuditSync", new object[1] { entry }, actors);
			}
		}

		private static int[] ModeratorActors()
		{
			Room currentRoom = PhotonNetwork.CurrentRoom;
			if (currentRoom == null)
			{
				return Array.Empty<int>();
			}
			int num = ((PhotonNetwork.LocalPlayer != null) ? PhotonNetwork.LocalPlayer.ActorNumber : (-1));
			List<int> list = new List<int>();
			foreach (Player value in currentRoom.Players.Values)
			{
				if (value != null && value.ActorNumber != num && AuthorizedActors.IsModeratorActor(value.ActorNumber))
				{
					list.Add(value.ActorNumber);
				}
			}
			return list.ToArray();
		}
	}
	internal static class Auth
	{
		internal static string ComputeAuthHash(string secret, string steamId)
		{
			using SHA256 sHA = SHA256.Create();
			byte[] array = sHA.ComputeHash(Encoding.UTF8.GetBytes(secret + steamId));
			StringBuilder stringBuilder = new StringBuilder(array.Length * 2);
			byte[] array2 = array;
			foreach (byte b in array2)
			{
				stringBuilder.Append(b.ToString("x2"));
			}
			return stringBuilder.ToString();
		}
	}
	internal sealed class CommandContext
	{
		internal int SenderActorNumber { get; }

		internal string SenderSteamId { get; }

		internal string SenderName { get; }

		internal bool SenderIsMaster { get; }

		internal Player? SenderPlayer { get; }

		internal object?[] Args { get; }

		internal CommandContext(int senderActorNumber, string senderSteamId, string senderName, bool senderIsMaster, Player? senderPlayer, object?[] args)
		{
			SenderActorNumber = senderActorNumber;
			SenderSteamId = senderSteamId;
			SenderName = senderName;
			SenderIsMaster = senderIsMaster;
			SenderPlayer = senderPlayer;
			Args = args;
		}

		internal string ArgString(int index)
		{
			return Args[index]?.ToString() ?? string.Empty;
		}
	}
	internal static class NetProtocol
	{
		internal const byte EventCode = 184;
	}
	internal readonly struct CommandEnvelope
	{
		internal readonly string Command;

		internal readonly string AuthHash;

		internal readonly string ClaimedSteamId;

		internal readonly object?[] Args;

		private CommandEnvelope(string command, string authHash, string claimedSteamId, object?[] args)
		{
			Command = command;
			AuthHash = authHash;
			ClaimedSteamId = claimedSteamId;
			Args = args;
		}

		internal static bool TryParse(object? customData, out CommandEnvelope envelope)
		{
			envelope = default(CommandEnvelope);
			if (!(customData is object[] array) || array.Length < 3)
			{
				return false;
			}
			string text = array[0]?.ToString();
			string text2 = array[1]?.ToString();
			string text3 = array[2]?.ToString();
			if (string.IsNullOrEmpty(text) || text2 == null || text3 == null)
			{
				return false;
			}
			object[] array2 = new object[array.Length - 3];
			for (int i = 0; i < array2.Length; i++)
			{
				array2[i] = array[i + 3];
			}
			envelope = new CommandEnvelope(text, text2, text3, array2);
			return true;
		}
	}
	internal sealed class CommandReceiver : IOnEventCallback, IInRoomCallbacks
	{
		private static readonly Dictionary<string, ICommandHandler> Handlers = BuildHandlers();

		internal static CommandReceiver? Instance { get; private set; }

		private static Dictionary<string, ICommandHandler> BuildHandlers()
		{
			ICommandHandler[] array = new ICommandHandler[24]
			{
				new KickPlayerCommand(),
				new KickGhostPlayerCommand(),
				new InitModeratorAckCommand(),
				new RemoveModeratorAckCommand(),
				new StartGameCommand(),
				new BackToLobbyCommand(),
				new StartCountdownCommand(),
				new CancelCountdownCommand(),
				new CancelCountdownRequestCommand(),
				new ModHelloCommand(),
				new GrantTokenCommand(),
				new PresentTokenCommand(),
				new ModUserAckCommand(),
				new HostCapsAckCommand(),
				new NameColorsAckCommand(),
				new AuditSyncCommand(),
				new RamSettingsCommand(),
				new RamActionCommand(),
				new AnnounceCommand(),
				new NotesSyncCommand(),
				new NotesUploadCommand(),
				new NoteDeleteCommand(),
				new NoteTombstoneCommand(),
				new PrivateVoiceAckCommand()
			};
			Dictionary<string, ICommandHandler> dictionary = new Dictionary<string, ICommandHandler>();
			ICommandHandler[] array2 = array;
			foreach (ICommandHandler commandHandler in array2)
			{
				dictionary.Add(commandHandler.Name, commandHandler);
			}
			return dictionary;
		}

		private CommandReceiver()
		{
			PhotonNetwork.AddCallbackTarget((object)this);
		}

		internal static void Init()
		{
			if (Instance == null)
			{
				Instance = new CommandReceiver();
			}
			AuditSync.Init();
		}

		public void OnEvent(EventData photonEvent)
		{
			if (photonEvent.Code != 184)
			{
				return;
			}
			try
			{
				HandleCommandEvent(photonEvent);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Error handling command event: {arg}");
			}
		}

		private static void HandleCommandEvent(EventData photonEvent)
		{
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			if (!CommandEnvelope.TryParse(photonEvent.CustomData, out var envelope))
			{
				if (SemiFunc.IsMasterClient())
				{
					Plugin.Logger.LogWarning((object)$"Malformed command event from actor {photonEvent.Sender} - dropped");
				}
				return;
			}
			int sender = photonEvent.Sender;
			Room currentRoom = PhotonNetwork.CurrentRoom;
			Player val = ((currentRoom != null) ? currentRoom.GetPlayer(sender, false) : null);
			bool senderIsMaster = val != null && val.IsMasterClient;
			string text = ((val != null) ? val.NickName : null) ?? "<left room>";
			string text2 = PlayerRegistry.Instance.Resolve(sender);
			string text3 = text2 ?? PlayerRegistry.Instance.BindIfAbsent(sender, envelope.ClaimedSteamId);
			if (!Handlers.TryGetValue(envelope.Command, out ICommandHandler value))
			{
				if (SemiFunc.IsMasterClient())
				{
					string arg = new string(envelope.Command.Where((char c) => !char.IsControl(c)).Take(32).ToArray());
					Plugin.Logger.LogInfo((object)$"Network event: Unknown command({envelope.Args.Length + 3}): {arg}");
				}
				return;
			}
			if (value.HostOnly)
			{
				if (!SemiFunc.IsMasterClient())
				{
					return;
				}
				if (text3 != null && ulong.TryParse(text3, out var result))
				{
					SteamId val2 = new SteamId
					{
						Value = result
					};
					if (((SteamId)(ref val2)).IsValid)
					{
						if (!(value is IUnauthenticatedCommand) && !AuthorizedActors.Contains(sender))
						{
							Plugin.Logger.LogWarning((object)("Unauthorized " + envelope.Command + " from: " + text + " (" + text3 + ") - dropped"));
							return;
						}
						goto IL_01f9;
					}
				}
				Plugin.Logger.LogWarning((object)("Invalid SteamID received in event from: " + text + " (" + (text3 ?? "null") + ")"));
				return;
			}
			if (SemiFunc.IsMasterClient())
			{
				return;
			}
			goto IL_01f9;
			IL_01f9:
			if (envelope.Args.Length < value.MinArgs)
			{
				Plugin.Logger.LogWarning((object)$"Command {envelope.Command} from {text} has {envelope.Args.Length} args, expected >= {value.MinArgs} - dropped");
			}
			else
			{
				value.Execute(new CommandContext(sender, text3 ?? "", text, senderIsMaster, val, envelope.Args));
			}
		}

		public void OnPlayerEnteredRoom(Player newPlayer)
		{
			try
			{
				Plugin.Logger.LogInfo((object)$"Player entered room: {newPlayer.NickName} (ActorNumber: {newPlayer.ActorNumber})");
				PlayerRegistry.Instance.Resolve(newPlayer.ActorNumber);
				NotesJoinToast.OnPlayerSeen(newPlayer);
				if (!SemiFunc.IsMasterClient())
				{
					CommandSender.Send("ModHello", Array.Empty<object>(), (ReceiverGroup)2);
				}
				if (SemiFunc.IsMasterClient())
				{
					PrivateVoiceSync.Resync();
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"OnPlayerEnteredRoom failed: {arg}");
			}
		}

		public void OnPlayerPropertiesUpdate(Player targetPlayer, Hashtable changedProps)
		{
			if (targetPlayer == null)
			{
				return;
			}
			try
			{
				PlayerRegistry.Instance.Resolve(targetPlayer.ActorNumber);
				NotesJoinToast.OnPlayerSeen(targetPlayer);
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"OnPlayerPropertiesUpdate failed: {arg}");
			}
		}

		public void OnPlayerLeftRoom(Player otherPlayer)
		{
			if (otherPlayer == null)
			{
				return;
			}
			AuthorizedActors.RemoveActor(otherPlayer.ActorNumber);
			try
			{
				PrivateVoiceSync.Resync();
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"PrivateVoiceSync.Resync failed: {arg}");
			}
		}

		public void OnRoomPropertiesUpdate(Hashtable propertiesThatChanged)
		{
		}

		public void OnMasterClientSwitched(Player newMasterClient)
		{
			StartCountdown.AbortLocal();
			HostCapabilities.Clear();
			NameColors.Clear();
			PrivateVoiceChannel.Clear();
			PrivateVoiceSync.Reset();
			NotificationCenter.RestampGrace();
			Moderators.Instance.Clear();
			RpcFloodMonitor.Instance.RearmHandled();
			NotesSync.OnMasterSwitched();
			JoinAnnouncer.Arm();
		}
	}
	internal static class CommandSender
	{
		internal static void Send(string command, object?[] args, ReceiverGroup receivers)
		{
			//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_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			object[] array = BuildPayload(command, args);
			if (array != null)
			{
				PhotonNetwork.RaiseEvent((byte)184, (object)array, new RaiseEventOptions
				{
					Receivers = receivers
				}, SendOptions.SendReliable);
			}
		}

		internal static void SendToActors(string command, object?[] args, int[] actors)
		{
			//IL_001a: 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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (actors != null && actors.Length != 0)
			{
				object[] array = BuildPayload(command, args);
				if (array != null)
				{
					PhotonNetwork.RaiseEvent((byte)184, (object)array, new RaiseEventOptions
					{
						TargetActors = actors
					}, SendOptions.SendReliable);
				}
			}
		}

		private static object?[]? BuildPayload(string command, object?[] args)
		{
			if ((Object)(object)PlayerAvatar.instance == (Object)null)
			{
				Plugin.Logger.LogWarning((object)("Send skipped: local avatar not ready (command: " + command + ")"));
				return null;
			}
			Plugin.Logger.LogDebug((object)("Send command: " + command));
			string text = SemiFunc.PlayerGetSteamID(PlayerAvatar.instance);
			object[] array = new object[3 + args.Length];
			array[0] = command;
			array[1] = Auth.ComputeAuthHash("", text);
			array[2] = text;
			args.CopyTo(array, 3);
			return array;
		}
	}
	internal static class FloodKeepAlive
	{
		private const int FlushEveryNFloodPackets = 50;

		private const int EpisodeGapMs = 5000;

		private static int _floodPacketsSinceFlush;

		private static bool _engaged;

		private static int _lastFloodTick;

		internal static void OnFloodPacket(LoadBalancingClient? client, bool oversized)
		{
			LoadBalancingPeer val = ((client != null) ? client.LoadBalancingPeer : null);
			if (val == null)
			{
				return;
			}
			int tickCount = Environment.TickCount;
			if (tickCount - _lastFloodTick > 5000)
			{
				_engaged = false;
			}
			_lastFloodTick = tickCount;
			_floodPacketsSinceFlush++;
			if (!oversized && _floodPacketsSinceFlush < 50)
			{
				return;
			}
			_floodPacketsSinceFlush = 0;
			try
			{
				if (((PhotonPeer)val).SendAcksOnly() && !_engaged)
				{
					_engaged = true;
					Plugin.Logger.LogWarning((object)"RPC flood - ACK keep-alive engaged (flushing acknowledgements to stay connected).");
				}
			}
			catch
			{
			}
		}

		internal static void FlushNow(LoadBalancingClient? client)
		{
			LoadBalancingPeer val = ((client != null) ? client.LoadBalancingPeer : null);
			if (val == null)
			{
				return;
			}
			try
			{
				((PhotonPeer)val).SendOutgoingCommands();
			}
			catch
			{
			}
		}

		internal static void Reset()
		{
			_floodPacketsSinceFlush = 0;
			_engaged = false;
			_lastFloodTick = 0;
		}
	}
	internal static class JoinAnnouncer
	{
		private static bool pendingHello;

		private static bool pendingToken;

		internal static void Arm()
		{
			pendingHello = (pendingToken = true);
		}

		internal static void Clear()
		{
			pendingHello = (pendingToken = false);
		}

		internal static void Tick()
		{
			if (!pendingHello && !pendingToken)
			{
				return;
			}
			if (!PhotonNetwork.InRoom)
			{
				Clear();
			}
			else if (SemiFunc.IsMasterClient())
			{
				Clear();
			}
			else
			{
				if ((Object)(object)PlayerAvatar.instance == (Object)null)
				{
					return;
				}
				if (pendingHello)
				{
					pendingHello = false;
					NotificationCenter.RestampGrace();
					CommandSender.Send("ModHello", Array.Empty<object>(), (ReceiverGroup)2);
				}
				if (!pendingToken)
				{
					return;
				}
				Player masterClient = PhotonNetwork.MasterClient;
				if (masterClient == null)
				{
					return;
				}
				string text = PlayerRegistry.Instance.Resolve(masterClient.ActorNumber);
				if (text != null)
				{
					pendingToken = false;
					string text2 = ClientTokenStore.Get(text);
					if (!string.IsNullOrEmpty(text2))
					{
						NotificationCenter.RestampGrace();
						CommandSender.Send("PresentToken", new object[1] { text2 }, (ReceiverGroup)2);
						ClientTokenStore.UpdateLabel(text, masterClient.NickName, GrantTokenCommand.CurrentLobbyLabel());
					}
				}
			}
		}
	}
	internal static class ModeratorSync
	{
		internal static void BroadcastFullModeratorList()
		{
			foreach (string allModerator in Moderators.Instance.GetAllModerators())
			{
				CommandSender.Send("InitModeratorAck", new object[1] { allModerator }, (ReceiverGroup)0);
			}
		}

		internal static void BroadcastRemoval(string? steamId)
		{
			if (!string.IsNullOrEmpty(steamId))
			{
				CommandSender.Send("RemoveModeratorAck", new object[1] { steamId }, (ReceiverGroup)0);
			}
		}
	}
	internal static class NameColorSync
	{
		internal static void Broadcast()
		{
			if (SemiFunc.IsMasterClient())
			{
				CommandSender.Send("NameColors", new object[1] { NameColors.ToWire() }, (ReceiverGroup)0);
			}
		}
	}
	internal static class NotesSync
	{
		private static bool uploadedThisSession;

		internal static void ResetSession()
		{
			uploadedThisSession = false;
		}

		internal static void OnMasterSwitched()
		{
			uploadedThisSession = false;
		}

		internal static void SendFullTo(int actor)
		{
			if (SemiFunc.IsMasterClient())
			{
				SendChunkedToActors("NotesSync", AllItems(), new int[1] { actor }, allowDone: true);
			}
		}

		internal static void UploadAllToHost()
		{
			if (!SemiFunc.IsMasterClient() && !uploadedThisSession)
			{
				uploadedThisSession = true;
				List<List<string>> list = PlayerNotesCore.Chunk(AllItems(), 15);
				if (list.Count == 0)
				{
					list.Add(new List<string>());
				}
				for (int i = 0; i < list.Count; i++)
				{
					CommandSender.Send("NotesUpload", BuildArgs(list[i], i == list.Count - 1), (ReceiverGroup)2);
				}
			}
		}

		internal static void SendOneToHost(PlayerNote note)
		{
			if (!SemiFunc.IsMasterClient())
			{
				CommandSender.Send("NotesUpload", new object[2]
				{
					"more",
					PlayerNotesCore.Encode(in note)
				}, (ReceiverGroup)2);
			}
		}

		internal static void ForwardNew(List<PlayerNote> notes, List<string> tombstones, int exceptActor)
		{
			if (!SemiFunc.IsMasterClient() || (notes.Count == 0 && tombstones.Count == 0))
			{
				return;
			}
			int[] array = AuthorizedModeratorActors(exceptActor);
			if (array.Length == 0)
			{
				return;
			}
			List<string> list = new List<string>(notes.Count + tombstones.Count);
			foreach (PlayerNote note in notes)
			{
				list.Add(PlayerNotesCore.Encode(note));
			}
			list.AddRange(tombstones);
			SendChunkedToActors("NotesSync", list, array, allowDone: false);
		}

		internal static void BroadcastTombstone(string id)
		{
			if (SemiFunc.IsMasterClient())
			{
				int[] array = AuthorizedModeratorActors(-1);
				if (array.Length != 0)
				{
					CommandSender.SendToActors("NoteTombstone", new object[1] { id }, array);
				}
			}
		}

		private static List<string> AllItems()
		{
			List<string> list = new List<string>();
			foreach (PlayerNote item in NotesStore.All())
			{
				list.Add(PlayerNotesCore.Encode(item));
			}
			foreach (string item2 in NotesStore.Tombstones())
			{
				list.Add(item2);
			}
			return list;
		}

		private static object?[] BuildArgs(List<string> chunk, bool done)
		{
			object[] array = new object[chunk.Count + 1];
			array[0] = (done ? "done" : "more");
			for (int i = 0; i < chunk.Count; i++)
			{
				array[i + 1] = chunk[i];
			}
			return array;
		}

		private static void SendChunkedToActors(string wire, List<string> items, int[] actors, bool allowDone)
		{
			if (actors.Length != 0)
			{
				List<List<string>> list = PlayerNotesCore.Chunk(items, 15);
				if (list.Count == 0)
				{
					list.Add(new List<string>());
				}
				for (int i = 0; i < list.Count; i++)
				{
					bool flag = i == list.Count - 1;
					CommandSender.SendToActors(wire, BuildArgs(list[i], allowDone && flag), actors);
				}
			}
		}

		private static int[] AuthorizedModeratorActors(int exceptActor)
		{
			Room currentRoom = PhotonNetwork.CurrentRoom;
			if (currentRoom == null)
			{
				return Array.Empty<int>();
			}
			int num = ((PhotonNetwork.LocalPlayer != null) ? PhotonNetwork.LocalPlayer.ActorNumber : (-1));
			List<int> list = new List<int>();
			foreach (Player value in currentRoom.Players.Values)
			{
				if (value != null && value.ActorNumber != num && value.ActorNumber != exceptActor && AuthorizedActors.IsModeratorActor(value.ActorNumber))
				{
					list.Add(value.ActorNumber);
				}
			}
			return list.ToArray();
		}
	}
	internal static class PrivateVoiceSync
	{
		private static int epoch;

		private static int[] Members()
		{
			HashSet<int> hashSet = new HashSet<int>(AuthorizedActors.Snapshot());
			if (PhotonNetwork.LocalPlayer != null)
			{
				hashSet.Add(PhotonNetwork.LocalPlayer.ActorNumber);
			}
			int[] array = new int[hashSet.Count];
			hashSet.CopyTo(array);
			return array;
		}

		internal static void Open()
		{
			if (SemiFunc.IsMasterClient())
			{
				epoch++;
				PrivateVoiceChannel.SetHost(active: true, PrivateVoiceChannel.GenerateRoomName(), epoch, Members());
				Plugin.Logger.LogInfo((object)$"Private voice channel opened (room {PrivateVoiceChannel.Fingerprint(PrivateVoiceChannel.RoomName)}, epoch {epoch})");
				Broadcast();
				AuditEvents.PrivateVoiceOpened();
			}
		}

		internal static void Close()
		{
			if (SemiFunc.IsMasterClient())
			{
				int[] actors = PrivateVoiceChannel.MemberActors();
				PrivateVoiceChannel.Clear();
				Plugin.Logger.LogInfo((object)"Private voice channel closed");
				SendToActors(actors);
				AuditEvents.PrivateVoiceClosed();
			}
		}

		internal static void Rotate(string reason)
		{
			if (!SemiFunc.IsMasterClient() || !PrivateVoiceChannel.Active)
			{
				return;
			}
			int[] array = PrivateVoiceChannel.MemberActors();
			epoch++;
			PrivateVoiceChannel.SetHost(active: true, PrivateVoiceChannel.GenerateRoomName(), epoch, Members());
			Plugin.Logger.LogInfo((object)$"Private voice channel key rotated ({reason}, room {PrivateVoiceChannel.Fingerprint(PrivateVoiceChannel.RoomName)}, epoch {epoch})");
			AuditEvents.PrivateVoiceRotated();
			int[] array2 = array;
			foreach (int actorNumber in array2)
			{
				if (!PrivateVoiceChannel.IsMemberActor(actorNumber))
				{
					SendOffTo(actorNumber);
				}
			}
			Broadcast();
		}

		internal static void Resync()
		{
			if (SemiFunc.IsMasterClient() && PrivateVoiceChannel.Active)
			{
				PrivateVoiceChannel.SetHost(active: true, PrivateVoiceChannel.RoomName, PrivateVoiceChannel.Epoch, Members());
				Broadcast();
			}
		}

		internal static void SendTo(int actorNumber)
		{
			if (SemiFunc.IsMasterClient())
			{
				if (!PrivateVoiceChannel.Active)
				{
					SendOffTo(actorNumber);
					return;
				}
				if (!PrivateVoiceChannel.IsMemberActor(actorNumber))
				{
					SendOffTo(actorNumber);
					return;
				}
				SendToActors(new int[1] { actorNumber });
			}
		}

		private static void Broadcast()
		{
			SendToActors(PrivateVoiceChannel.MemberActors());
		}

		private static void SendToActors(int[] actors)
		{
			if (actors.Length != 0)
			{
				object[] args = ((!PrivateVoiceChannel.Active) ? new object[4] { "0", "", "0", "" } : new object[4]
				{
					"1",
					PrivateVoiceChannel.RoomName,
					PrivateVoiceChannel.Epoch.ToString(),
					string.Join(",", PrivateVoiceChannel.MemberActors())
				});
				CommandSender.SendToActors("PrivateVoiceAck", args, actors);
			}
		}

		private static void SendOffTo(int actorNumber)
		{
			CommandSender.SendToActors("PrivateVoiceAck", new object[4] { "0", "", "0", "" }, new int[1] { actorNumber });
		}

		internal static void Reset()
		{
			epoch = 0;
		}
	}
	internal sealed class RpcFloodMonitor
	{
		private sealed class Tracker
		{
			internal readonly long[] BucketSlot = new long[10];

			internal readonly int[] BucketCount = new int[10];

			internal int PeakRate;

			internal int PeakBytes;

			internal readonly Dictionary<string, int> NameCounts = new Dictionary<string, int>();

			internal Tracker()
			{
				for (int i = 0; i < 10; i++)
				{
					BucketSlot[i] = -1L;
				}
			}
		}

		internal readonly struct RecordResult
		{
			internal readonly int Total;

			internal readonly bool NewPeakRate;

			internal readonly bool NewPeakBytes;

			internal RecordResult(int total, bool newPeakRate, bool newPeakBytes)
			{
				Total = total;
				NewPeakRate = newPeakRate;
				NewPeakBytes = newPeakBytes;
			}
		}

		private const int Buckets = 10;

		private const float BucketSeconds = 0.1f;

		private const int MaxTrackedNames = 32;

		private const int MaxNameLength = 64;

		private const string OtherNamesBucket = "<other>";

		private readonly Dictionary<int, Tracker> trackers = new Dictionary<int, Tracker>();

		private readonly HashSet<int> handledActors = new HashSet<int>();

		internal static RpcFloodMonitor Instance { get; } = new RpcFloodMonitor();

		private RpcFloodMonitor()
		{
		}

		internal RecordResult Record(int actorNumber, string rpcName, int sizeBytes)
		{
			if (!trackers.TryGetValue(actorNumber, out Tracker value))
			{
				value = new Tracker();
				trackers[actorNumber] = value;
			}
			long num = (long)(Time.unscaledTime / 0.1f);
			int num2 = (int)((num % 10 + 10) % 10);
			if (value.BucketSlot[num2] != num)
			{
				value.BucketSlot[num2] = num;
				value.BucketCount[num2] = 0;
			}
			value.BucketCount[num2]++;
			int num3 = 0;
			for (int i = 0; i < 10; i++)
			{
				if (num - value.BucketSlot[i] < 10)
				{
					num3 += value.BucketCount[i];
				}
			}
			bool flag = num3 > value.PeakRate;
			if (flag)
			{
				value.PeakRate = num3;
			}
			bool flag2 = sizeBytes > value.PeakBytes;
			if (flag2)
			{
				value.PeakBytes = sizeBytes;
			}
			string key = ((rpcName.Length > 64) ? rpcName.Substring(0, 64) : rpcName);
			if (!value.NameCounts.ContainsKey(key) && value.NameCounts.Count >= 32)
			{
				key = "<other>";
			}
			value.NameCounts.TryGetValue(key, out var value2);
			value.NameCounts[key] = value2 + 1;
			return new RecordResult(num3, flag, flag2);
		}

		internal int PeakRate(int actorNumber)
		{
			if (!trackers.TryGetValue(actorNumber, out Tracker value))
			{
				return 0;
			}
			return value.PeakRate;
		}

		internal int PeakBytes(int actorNumber)
		{
			if (!trackers.TryGetValue(actorNumber, out Tracker value))
			{
				return 0;
			}
			return value.PeakBytes;
		}

		internal string TopNames(int actorNumber, int n)
		{
			if (!trackers.TryGetValue(actorNumber, out Tracker value) || value.NameCounts.Count == 0)
			{
				return "none";
			}
			List<KeyValuePair<string, int>> list = new List<KeyValuePair<string, int>>(value.NameCounts);
			list.Sort((KeyValuePair<string, int> a, KeyValuePair<string, int> b) => b.Value.CompareTo(a.Value));
			StringBuilder stringBuilder = new StringBuilder();
			for (int num = 0; num < list.Count && num < n; num++)
			{
				if (num > 0)
				{
					stringBuilder.Append(", ");
				}
				stringBuilder.Append(list[num].Key).Append('=').Append(list[num].Value);
			}
			return stringBuilder.ToString();
		}

		internal bool MarkHandled(int actorNumber)
		{
			return handledActors.Add(actorNumber);
		}

		internal void RearmHandled()
		{
			handledActors.Clear();
		}

		internal void Forget(int actorNumber)
		{
			trackers.Remove(actorNumber);
			handledActors.Remove(actorNumber);
		}

		internal void Clear()
		{
			trackers.Clear();
			handledActors.Clear();
		}
	}
	internal static class StartCountdown
	{
		internal const int DefaultSeconds = 5;

		private static float endsAtRealtime;

		private static bool hostOwned;

		internal static bool Active { get; private set; }

		internal static int RemainingSeconds
		{
			get
			{
				if (!Active)
				{
					return 0;
				}
				return Mathf.Max(0, Mathf.CeilToInt(endsAtRealtime - Time.realtimeSinceStartup));
			}
		}

		internal static void BeginHostAuthoritative(int seconds)
		{
			if (SemiFunc.IsMasterClient() && !Active && SemiFunc.RunIsLobbyMenu() && (!((Object)(object)MenuPageLobby.instance != (Object)null) || !MenuPageLobby.instance.joiningPlayer))
			{
				if (seconds <= 0)
				{
					GameActions.StartGame();
					return;
				}
				hostOwned = true;
				endsAtRealtime = Time.realtimeSinceStartup + (float)seconds;
				Active = true;
				CommandSender.Send("StartCountdown", new object[1] { seconds }, (ReceiverGroup)0);
				AuditEvents.CountdownBegun(seconds);
			}
		}

		internal static void CancelHostAuthoritative()
		{
			if (SemiFunc.IsMasterClient() && Active)
			{
				Clear();
				BroadcastClear();
			}
		}

		private static void BroadcastClear()
		{
			CommandSender.Send("CancelCountdown", Array.Empty<object>(), (ReceiverGroup)0);
		}

		internal static void BeginDisplayOnly(int seconds)
		{
			if (!SemiFunc.IsMasterClient() && seconds > 0)
			{
				hostOwned = false;
				endsAtRealtime = Time.realtimeSinceStartup + (float)seconds;
				Active = true;
			}
		}

		internal static void CancelDisplayOnly()
		{
			if (!SemiFunc.IsMasterClient())
			{
				Clear();
			}
		}

		internal static void RequestCancelFromUi()
		{
			if (SemiFunc.IsMasterClient())
			{
				if (Active)
				{
					AuditEvents.CountdownCancelled("host");
					CancelHostAuthoritative();
				}
			}
			else
			{
				CommandSender.Send("CancelCountdownRequest", Array.Empty<object>(), (ReceiverGroup)2);
			}
		}

		internal static void Tick()
		{
			if (!Active)
			{
				return;
			}
			try
			{
				if (!SemiFunc.RunIsLobbyMenu())
				{
					Clear();
				}
				else if (SemiFunc.IsMasterClient() && hostOwned)
				{
					if ((Object)(object)MenuPageLobby.instance != (Object)null && MenuPageLobby.instance.joiningPlayer)
					{
						AuditEvents.CountdownCancelledPlayerJoining();
						CancelHostAuthoritative();
					}
					else if (Time.realtimeSinceStartup >= endsAtRealtime)
					{
						Clear();
						BroadcastClear();
						AuditEvents.RunStarted();
						GameActions.StartGame();
					}
				}
			}
			catch
			{
			}
		}

		internal static void AbortLocal()
		{
			Clear();
		}

		private static void Clear()
		{
			Active = false;
			endsAtRealtime = 0f;
			hostOwned = false;
		}
	}
}
namespace SharePermissions.Net.Commands
{
	internal sealed class AnnounceCommand : ICommandHandler
	{
		internal const string WireName = "Announce";

		private const float MinIntervalSeconds = 2f;

		private const int MaxPerSession = 500;

		private static float lastAt;

		private static int seenThisSession;

		public string Name => "Announce";

		public int MinArgs => 1;

		public bool HostOnly => false;

		internal static void ResetLimits()
		{
			lastAt = 0f;
			seenThisSession = 0;
		}

		public void Execute(CommandContext ctx)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (!ctx.SenderIsMaster || seenThisSession >= 500)
			{
				return;
			}
			float realtimeSinceStartup = Time.realtimeSinceStartup;
			if (!(lastAt > 0f) || !(realtimeSinceStartup - lastAt < 2f))
			{
				string text = AnnounceText.Sanitize(ctx.ArgString(0));
				if (text.Length != 0)
				{
					lastAt = realtimeSinceStartup;
					seenThisSession++;
					NotificationCenter.EnqueueDirect("Announcement: " + text, ModStyle.SevAnnounce);
				}
			}
		}
	}
	internal sealed class AuditSyncCommand : ICommandHandler
	{
		internal const string WireName = "AuditSync";

		private const float BurstCapacity = 150f;

		private const float RefillPerSecond = 25f;

		private const int MaxSyncedPerSession = 10000;

		private static float tokens = 150f;

		private static float lastRefillTime;

		private static int syncedThisSession;

		private static bool ceilingLogged;

		public string Name => "AuditSync";

		public int MinArgs => 1;

		public bool HostOnly => false;

		internal static void ResetLimits()
		{
			tokens = 150f;
			lastRefillTime = 0f;
			syncedThisSession = 0;
			ceilingLogged = false;
		}

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster && AllowEntry())
			{
				string entry = ctx.ArgString(0);
				AuditLog.AddSynced(entry);
				if (ctx.Args.Length > 1)
				{
					NotificationCenter.OnAuditEntry(entry, ctx.ArgString(1));
				}
			}
		}

		private static bool AllowEntry()
		{
			if (syncedThisSession >= 10000)
			{
				if (!ceilingLogged)
				{
					ceilingLogged = true;
					Plugin.Logger.LogWarning((object)$"AuditSync: per-session cap of {10000} synced entries reached - dropping further entries this session");
				}
				return false;
			}
			float unscaledTime = Time.unscaledTime;
			if (lastRefillTime <= 0f)
			{
				lastRefillTime = unscaledTime;
			}
			tokens = Mathf.Min(150f, tokens + (unscaledTime - lastRefillTime) * 25f);
			lastRefillTime = unscaledTime;
			if (tokens < 1f)
			{
				return false;
			}
			tokens -= 1f;
			syncedThisSession++;
			return true;
		}
	}
	internal sealed class BackToLobbyCommand : ICommandHandler
	{
		internal const string WireName = "BackToLobby";

		public string Name => "BackToLobby";

		public int MinArgs => 0;

		public bool HostOnly => true;

		public void Execute(CommandContext ctx)
		{
			Plugin.Logger.LogInfo((object)"Network event: BackToLobby command received.");
			AuditEvents.BackToLobbyRequest(ctx.SenderName, ctx.SenderSteamId);
			GameActions.ReturnToLobby();
		}
	}
	internal sealed class CancelCountdownCommand : ICommandHandler
	{
		internal const string WireName = "CancelCountdown";

		public string Name => "CancelCountdown";

		public int MinArgs => 0;

		public bool HostOnly => false;

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster)
			{
				StartCountdown.CancelDisplayOnly();
			}
		}
	}
	internal sealed class CancelCountdownRequestCommand : ICommandHandler
	{
		internal const string WireName = "CancelCountdownRequest";

		public string Name => "CancelCountdownRequest";

		public int MinArgs => 0;

		public bool HostOnly => true;

		public void Execute(CommandContext ctx)
		{
			if (StartCountdown.Active)
			{
				AuditEvents.CountdownCancelled(ctx.SenderName);
				StartCountdown.CancelHostAuthoritative();
			}
		}
	}
	internal sealed class GrantTokenCommand : ICommandHandler
	{
		internal const string WireName = "GrantToken";

		private const float AcceptCooldownSeconds = 1f;

		private static float nextAcceptTime;

		public string Name => "GrantToken";

		public int MinArgs => 1;

		public bool HostOnly => false;

		public void Execute(CommandContext ctx)
		{
			if (!ctx.SenderIsMaster)
			{
				return;
			}
			string text = ctx.ArgString(0);
			if (TokenGenerator.IsHexToken(text))
			{
				float unscaledTime = Time.unscaledTime;
				if (!(unscaledTime < nextAcceptTime))
				{
					nextAcceptTime = unscaledTime + 1f;
					ClientTokenStore.Save(ctx.SenderSteamId, text, ctx.SenderName, CurrentLobbyLabel());
					Plugin.Logger.LogInfo((object)"Received a moderator token from the host");
				}
			}
		}

		internal static string CurrentLobbyLabel()
		{
			Room currentRoom = PhotonNetwork.CurrentRoom;
			string text = PlayerNotesCore.SanitizeName((currentRoom != null) ? currentRoom.Name : null, 40);
			if (text.Length == 0 || PlayerNotesCore.LooksLikeRoomGuid(text))
			{
				Player masterClient = PhotonNetwork.MasterClient;
				text = PlayerNotesCore.SanitizeName((masterClient != null) ? masterClient.NickName : null, 40);
			}
			return text;
		}
	}
	internal sealed class HostCapsAckCommand : ICommandHandler
	{
		internal const string WireName = "HostCapsAck";

		public string Name => "HostCapsAck";

		public int MinArgs => 1;

		public bool HostOnly => false;

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster)
			{
				HostCapabilities.Set(ctx.ArgString(0));
			}
		}
	}
	internal interface ICommandHandler
	{
		string Name { get; }

		int MinArgs { get; }

		bool HostOnly { get; }

		void Execute(CommandContext ctx);
	}
	internal sealed class InitModeratorAckCommand : ICommandHandler
	{
		internal const string WireName = "InitModeratorAck";

		public string Name => "InitModeratorAck";

		public int MinArgs => 1;

		public bool HostOnly => false;

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster)
			{
				Moderators.Instance.AddModerator(ctx.ArgString(0));
			}
		}
	}
	internal interface IUnauthenticatedCommand
	{
	}
	internal sealed class KickGhostPlayerCommand : ICommandHandler
	{
		internal const string WireName = "KickGhostPlayer";

		internal const string FloodSource = "flood";

		public string Name => "KickGhostPlayer";

		public int MinArgs => 2;

		public bool HostOnly => true;

		public void Execute(CommandContext ctx)
		{
			string text = ctx.ArgString(0);
			if (!int.TryParse(text, out var result))
			{
				Plugin.Logger.LogWarning((object)("Invalid ActorNumber received for KickGhostPlayer: " + text));
				return;
			}
			Room currentRoom = PhotonNetwork.CurrentRoom;
			Player val = ((currentRoom != null) ? currentRoom.GetPlayer(result, false) : null);
			if (val == null)
			{
				Plugin.Logger.LogWarning((object)$"Ghost player with ActorNumber {result} not found");
				return;
			}
			if (val.IsMasterClient)
			{
				Plugin.Logger.LogWarning((object)$"Ignoring ghost kick request for master client (ActorNumber: {result}) from: {ctx.SenderName}");
				return;
			}
			string text2 = PlayerRegistry.Instance.TryGetSteamId(result) ?? val.UserId;
			if (AuthorizedActors.IsModeratorActor(result) && !ctx.SenderIsMaster)
			{
				Plugin.Logger.LogWarning((object)$"Ignoring ghost kick request for moderator (ActorNumber: {result}, SteamID: {text2}) from: {ctx.SenderName}");
				return;
			}
			string text3 = ctx.ArgString(1);
			bool flag = text3 != "kick";
			bool flag2 = text3 == "pban";
			string targetName = MenuUiHelpers.SanitizePlayerName(val.NickName, $"Unknown_{result}");
			PBanOutcome pban = (flag2 ? GameActions.RecordPersistentBan(text2, targetName, ctx.SenderName, ctx.SenderSteamId) : PBanOutcome.None);
			GameActions.KickByActorNumber(result, flag);
			AuditEvents.GhostKickBan(flag, result, val.NickName, text2, ctx.SenderName, ctx.SenderSteamId, pban);
			string arg = MenuUiHelpers.SanitizePlayerName(ctx.SenderName, $"actor {ctx.SenderActorNumber}");
			string arg2 = ((ctx.Args.Length > 2 && ctx.ArgString(2) == "flood") ? "RPC-flood auto-kick" : "manual moderator action");
			Plugin.Logger.LogInfo((object)("Ghost player " + (flag ? "ban" : "kick") + " event raised: " + val.NickName + " " + string.Format("(ActorNumber: {0}, SteamID: {1}) — requested by {2} ", result, text2 ?? "unknown", arg) + $"(SteamID: {ctx.SenderSteamId}, actor {ctx.SenderActorNumber}); origin: {arg2}"));
		}
	}
	internal sealed class KickPlayerCommand : ICommandHandler
	{
		internal const string WireName = "KickPlayer";

		public string Name => "KickPlayer";

		public int MinArgs => 2;

		public bool HostOnly => true;

		public void Execute(CommandContext ctx)
		{
			string text = ctx.ArgString(0);
			string text2 = ctx.ArgString(1);
			PlayerAvatar val = SemiFunc.PlayerGetFromSteamID(text);
			PhotonView val2 = (((Object)(object)val == (Object)null) ? null : ((Component)val).GetComponent<PhotonView>());
			int num = (((Object)(object)val2 != (Object)null && val2.Owner != null) ? val2.Owner.ActorNumber : PlayerRegistry.Instance.FindActorNumber(text));
			string text3 = (((Object)(object)val != (Object)null) ? SemiFunc.PlayerGetName(val) : ((num > 0) ? $"actor {num}" : "<gone>"));
			bool flag = num > 0 && PhotonNetwork.MasterClient != null && PhotonNetwork.MasterClient.ActorNumber == num;
			bool flag2 = ((num > 0) ? AuthorizedActors.IsModeratorActor(num) : Moderators.Instance.IsModerator(text));
			string text4 = ((text2 == "kick") ? "Kick" : "Ban");
			if (flag || (flag2 && !ctx.SenderIsMaster))
			{
				Plugin.Logger.LogWarning((object)("Ignoring " + text4 + " request for protected target " + text3 + " (" + text + ") from player:" + ctx.SenderName + "(" + ctx.SenderSteamId + ")"));
				return;
			}
			if ((Object)(object)val == (Object)null && num <= 0)
			{
				Plugin.Logger.LogWarning((object)(text4 + " request for " + text + " from player:" + ctx.SenderName + "(" + ctx.SenderSteamId + ") ignored - target not found (already left?)"));
				return;
			}
			bool ban = text2 != "kick";
			bool flag3 = text2 == "pban";
			PBanOutcome pban = (flag3 ? GameActions.RecordPersistentBan(text, text3, ctx.SenderName, ctx.SenderSteamId) : PBanOutcome.None);
			AuditEvents.KickBanRequest(ban, text3, text, num, flag2, ctx.SenderName, ctx.SenderSteamId, pban);
			Plugin.Logger.LogInfo((object)(text4 + " request " + text3 + " (" + text + ") from player:" + ctx.SenderName + "(" + ctx.SenderSteamId + ")"));
			if ((Object)(object)val != (Object)null && !flag3)
			{
				GameActions.Kick(val, ban);
			}
			else
			{
				GameActions.KickByActorNumber(num, ban);
			}
		}
	}
	internal sealed class ModHelloCommand : ICommandHandler, IUnauthenticatedCommand
	{
		internal const string WireName = "ModHello";

		private static readonly Dictionary<int, float> LastHelloAt = new Dictionary<int, float>();

		private const float CooldownSeconds = 1f;

		public string Name => "ModHello";

		public int MinArgs => 0;

		public bool HostOnly => true;

		internal static void ResetRateLimit()
		{
			LastHelloAt.Clear();
		}

		public void Execute(CommandContext ctx)
		{
			if (LastHelloAt.TryGetValue(ctx.SenderActorNumber, out var value) && Time.realtimeSinceStartup - value < 1f)
			{
				return;
			}
			LastHelloAt[ctx.SenderActorNumber] = Time.realtimeSinceStartup;
			Plugin.Logger.LogInfo((object)("Network event: ModHello from steamId: " + ctx.SenderSteamId));
			ModUsers.Instance.Add(ctx.SenderSteamId);
			ModeratorSync.BroadcastFullModeratorList();
			foreach (string item in ModUsers.Instance.GetAll())
			{
				CommandSender.Send("ModUserAck", new object[1] { item }, (ReceiverGroup)0);
			}
			List<string> list = new List<string>(2);
			if (BanEnforcerBridge.IsAvailable)
			{
				list.Add("pban");
			}
			if (AdminMenuBridge.IsAvailable && ModConfig.GrantAdminMenu.Value)
			{
				list.Add("ram");
			}
			CommandSender.Send("HostCapsAck", new object[1] { string.Join(",", list) }, (ReceiverGroup)0);
			NameColorSync.Broadcast();
			if (AuthorizedActors.Contains(ctx.SenderActorNumber))
			{
				PrivateVoiceSync.SendTo(ctx.SenderActorNumber);
			}
		}
	}
	internal sealed class ModUserAckCommand : ICommandHandler
	{
		internal const string WireName = "ModUserAck";

		public string Name => "ModUserAck";

		public int MinArgs => 1;

		public bool HostOnly => false;

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster)
			{
				ModUsers.Instance.Add(ctx.ArgString(0));
			}
		}
	}
	internal sealed class NameColorsAckCommand : ICommandHandler
	{
		internal const string WireName = "NameColors";

		public string Name => "NameColors";

		public int MinArgs => 1;

		public bool HostOnly => false;

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster)
			{
				NameColors.SetFromWire(ctx.ArgString(0));
			}
		}
	}
	internal sealed class NoteDeleteCommand : ICommandHandler
	{
		private sealed class Bucket
		{
			internal float Tokens = 30f;

			internal float LastRefill;
		}

		internal const string WireName = "NoteDelete";

		private const float BurstCapacity = 30f;

		private const float RefillPerSecond = 1f;

		private static readonly Dictionary<int, Bucket> buckets = new Dictionary<int, Bucket>();

		public string Name => "NoteDelete";

		public int MinArgs => 1;

		public bool HostOnly => true;

		internal static void ResetLimits()
		{
			buckets.Clear();
		}

		public void Execute(CommandContext ctx)
		{
			if (!Allow(ctx.SenderActorNumber))
			{
				return;
			}
			string text = ctx.ArgString(0);
			if (!PlayerNotesCore.IsHexId(text))
			{
				return;
			}
			PlayerNote? playerNote = NotesStore.Find(text);
			if (playerNote.HasValue)
			{
				if (playerNote.Value.AuthorSteamId != ctx.SenderSteamId)
				{
					Plugin.Logger.LogWarning((object)("NoteDelete for a foreign note from " + ctx.SenderName + " (" + ctx.SenderSteamId + ") - dropped"));
				}
				else
				{
					NotesStore.Delete(text);
					NotesSync.BroadcastTombstone(text);
				}
			}
		}

		private static bool Allow(int actor)
		{
			if (!buckets.TryGetValue(actor, out Bucket value))
			{
				value = new Bucket();
				buckets[actor] = value;
			}
			float unscaledTime = Time.unscaledTime;
			if (value.LastRefill <= 0f)
			{
				value.LastRefill = unscaledTime;
			}
			value.Tokens = Mathf.Min(30f, value.Tokens + (unscaledTime - value.LastRefill) * 1f);
			value.LastRefill = unscaledTime;
			if (value.Tokens < 1f)
			{
				return false;
			}
			value.Tokens -= 1f;
			return true;
		}
	}
	internal sealed class NotesSyncCommand : ICommandHandler
	{
		internal const string WireName = "NotesSync";

		private const float BurstCapacity = 300f;

		private const float RefillPerSecond = 20f;

		private const int MaxPerSession = 5000;

		private static float tokens = 300f;

		private static float lastRefillTime;

		private static int seenThisSession;

		public string Name => "NotesSync";

		public int MinArgs => 1;

		public bool HostOnly => false;

		internal static void ResetLimits()
		{
			tokens = 300f;
			lastRefillTime = 0f;
			seenThisSession = 0;
		}

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster && ctx.Args.Length <= 16 && Allow())
			{
				List<string> list = new List<string>(ctx.Args.Length - 1);
				for (int i = 1; i < ctx.Args.Length; i++)
				{
					list.Add(ctx.Args[i]?.ToString());
				}
				NotesStore.ApplyIncoming(list, out List<PlayerNote> _, out List<string> _);
				if (ctx.ArgString(0) == "done")
				{
					NotesSync.UploadAllToHost();
				}
			}
		}

		private static bool Allow()
		{
			if (seenThisSession >= 5000)
			{
				return false;
			}
			float unscaledTime = Time.unscaledTime;
			if (lastRefillTime <= 0f)
			{
				lastRefillTime = unscaledTime;
			}
			tokens = Mathf.Min(300f, tokens + (unscaledTime - lastRefillTime) * 20f);
			lastRefillTime = unscaledTime;
			if (tokens < 1f)
			{
				return false;
			}
			tokens -= 1f;
			seenThisSession++;
			return true;
		}
	}
	internal sealed class NotesUploadCommand : ICommandHandler
	{
		private sealed class Bucket
		{
			internal float Tokens = 150f;

			internal float LastRefill;
		}

		internal const string WireName = "NotesUpload";

		private const float BurstCapacity = 150f;

		private const float RefillPerSecond = 10f;

		private static readonly Dictionary<int, Bucket> buckets = new Dictionary<int, Bucket>();

		public string Name => "NotesUpload";

		public int MinArgs => 1;

		public bool HostOnly => true;

		internal static void ResetLimits()
		{
			buckets.Clear();
		}

		public void Execute(CommandContext ctx)
		{
			if (Allow(ctx.SenderActorNumber) && ctx.Args.Length <= 16)
			{
				List<string> list = new List<string>(ctx.Args.Length - 1);
				for (int i = 1; i < ctx.Args.Length; i++)
				{
					list.Add(ctx.Args[i]?.ToString());
				}
				NotesStore.ApplyIncoming(list, out List<PlayerNote> addedNotes, out List<string> addedTombstones);
				NotesSync.ForwardNew(addedNotes, addedTombstones, ctx.SenderActorNumber);
			}
		}

		private static bool Allow(int actor)
		{
			if (!buckets.TryGetValue(actor, out Bucket value))
			{
				value = new Bucket();
				buckets[actor] = value;
			}
			float unscaledTime = Time.unscaledTime;
			if (value.LastRefill <= 0f)
			{
				value.LastRefill = unscaledTime;
			}
			value.Tokens = Mathf.Min(150f, value.Tokens + (unscaledTime - value.LastRefill) * 10f);
			value.LastRefill = unscaledTime;
			if (value.Tokens < 1f)
			{
				return false;
			}
			value.Tokens -= 1f;
			return true;
		}
	}
	internal sealed class NoteTombstoneCommand : ICommandHandler
	{
		internal const string WireName = "NoteTombstone";

		private const float BurstCapacity = 60f;

		private const float RefillPerSecond = 5f;

		private const int MaxPerSession = 2000;

		private static float tokens = 60f;

		private static float lastRefillTime;

		private static int seenThisSession;

		public string Name => "NoteTombstone";

		public int MinArgs => 1;

		public bool HostOnly => false;

		internal static void ResetLimits()
		{
			tokens = 60f;
			lastRefillTime = 0f;
			seenThisSession = 0;
		}

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster && ctx.Args.Length <= 15 && Allow())
			{
				List<string> list = new List<string>(ctx.Args.Length);
				for (int i = 0; i < ctx.Args.Length; i++)
				{
					list.Add(ctx.Args[i]?.ToString());
				}
				NotesStore.ApplyIncoming(list, out List<PlayerNote> _, out List<string> _);
			}
		}

		private static bool Allow()
		{
			if (seenThisSession >= 2000)
			{
				return false;
			}
			float unscaledTime = Time.unscaledTime;
			if (lastRefillTime <= 0f)
			{
				lastRefillTime = unscaledTime;
			}
			tokens = Mathf.Min(60f, tokens + (unscaledTime - lastRefillTime) * 5f);
			lastRefillTime = unscaledTime;
			if (tokens < 1f)
			{
				return false;
			}
			tokens -= 1f;
			seenThisSession++;
			return true;
		}
	}
	internal sealed class PresentTokenCommand : ICommandHandler, IUnauthenticatedCommand
	{
		internal const string WireName = "PresentToken";

		public string Name => "PresentToken";

		public int MinArgs => 1;

		public bool HostOnly => true;

		public void Execute(CommandContext ctx)
		{
			string token = ctx.ArgString(0);
			if (PromotedTokenStore.Contains(token))
			{
				bool flag = AuthorizedActors.Contains(ctx.SenderActorNumber);
				AuthorizedActors.Authorize(ctx.SenderActorNumber, token);
				PromotedTokenStore.Relabel(token, ctx.SenderSteamId, ctx.SenderName);
				Moderators.Instance.AddModerator(ctx.SenderSteamId);
				ModeratorSync.BroadcastFullModeratorList();
				if (!flag)
				{
					AuditSync.SendBacklogTo(ctx.SenderActorNumber);
					NotesSync.SendFullTo(ctx.SenderActorNumber);
				}
				if (!flag)
				{
					PrivateVoiceSync.Resync();
				}
				PrivateVoiceSync.SendTo(ctx.SenderActorNumber);
				Plugin.Logger.LogInfo((object)$"Moderator token accepted from {ctx.SenderName} (actor {ctx.SenderActorNumber}) - authorized this session");
			}
		}
	}
	internal sealed class PrivateVoiceAckCommand : ICommandHandler
	{
		internal const string WireName = "PrivateVoiceAck";

		public string Name => "PrivateVoiceAck";

		public int MinArgs => 4;

		public bool HostOnly => false;

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster)
			{
				bool flag = PrivateVoiceChannel.ApplyWire(ctx.ArgString(0), ctx.ArgString(1), ctx.ArgString(2), ctx.ArgString(3));
				Plugin.Logger.LogInfo((object)(flag ? $"Private voice channel: on (room {PrivateVoiceChannel.Fingerprint(PrivateVoiceChannel.RoomName)}, epoch {PrivateVoiceChannel.Epoch})" : "Private voice channel: off"));
			}
		}
	}
	internal sealed class RamActionCommand : ICommandHandler
	{
		internal const string WireName = "RamAction";

		private const int MaxArgLength = 128;

		public string Name => "RamAction";

		public int MinArgs => 2;

		public bool HostOnly => true;

		public void Execute(CommandContext ctx)
		{
			if (!ModConfig.GrantAdminMenu.Value)
			{
				Plugin.Logger.LogInfo((object)("RamAction from " + ctx.SenderName + " ignored - admin-menu grant is disabled"));
				return;
			}
			if (!AdminMenuBridge.IsAvailable)
			{
				Plugin.Logger.LogInfo((object)("RamAction from " + ctx.SenderName + " ignored - Admin Menu not installed on this host"));
				return;
			}
			string text = ctx.ArgString(0);
			string text2 = ctx.ArgString(1);
			if (text.Length == 0 || text.Length > 128 || text2.Length > 128)
			{
				Plugin.Logger.LogWarning((object)("RamAction from " + ctx.SenderName + " dropped - malformed verb/argument length"));
				return;
			}
			PlayerAvatar val = SemiFunc.PlayerGetFromSteamID(ctx.SenderSteamId);
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Logger.LogWarning((object)("RamAction from " + ctx.SenderName + " dropped - requester has no avatar"));
				return;
			}
			AdminMenuActions.Resolve();
			if (AdminMenuActions.Execute(text, text2, val))
			{
				string text3 = RamVerbs.Describe(text);
				Plugin.Logger.LogInfo((object)("Admin menu action '" + text3 + "' from " + ctx.SenderName + " (" + ctx.SenderSteamId + ")"));
				AuditEvents.AdminMenuAction(text3, ctx.SenderName, ctx.SenderSteamId, ctx.SenderActorNumber, IsPlayerVerb(text) ? text2 : null);
			}
		}

		private static bool IsPlayerVerb(string verb)
		{
			switch (verb)
			{
			case "heal":
			case "kill":
			case "tpto":
			case "revive":
			case "summon":
			case "crown":
			case "truck":
				return true;
			default:
				return false;
			}
		}
	}
	internal sealed class RamSettingsCommand : ICommandHandler
	{
		internal const string WireName = "RamSettings";

		private const int MaxJsonLength = 16384;

		public string Name => "RamSettings";

		public int MinArgs => 1;

		public bool HostOnly => true;

		public void Execute(CommandContext ctx)
		{
			if (!ModConfig.GrantAdminMenu.Value)
			{
				Plugin.Logger.LogInfo((object)("RamSettings from " + ctx.SenderName + " ignored - admin-menu grant is disabled"));
				return;
			}
			if (!AdminMenuBridge.IsAvailable)
			{
				Plugin.Logger.LogInfo((object)("RamSettings from " + ctx.SenderName + " ignored - Admin Menu not installed on this host"));
				return;
			}
			string text = ctx.ArgString(0);
			if (text.Length == 0 || text.Length > 16384)
			{
				Plugin.Logger.LogWarning((object)$"RamSettings from {ctx.SenderName} dropped - payload length {text.Length} outside 1..{16384}");
			}
			else if (!(text == AdminMenuBridge.GetSettingsJson()) && AdminMenuBridge.ApplySettingsJson(text))
			{
				Plugin.Logger.LogInfo((object)("Admin menu settings applied from " + ctx.SenderName + " (" + ctx.SenderSteamId + ")"));
				AdminMenuBridge.BroadcastSettings();
				AuditEvents.AdminMenuSettingsChanged(ctx.SenderName, ctx.SenderSteamId, ctx.SenderActorNumber);
			}
		}
	}
	internal sealed class RemoveModeratorAckCommand : ICommandHandler
	{
		internal const string WireName = "RemoveModeratorAck";

		public string Name => "RemoveModeratorAck";

		public int MinArgs => 1;

		public bool HostOnly => false;

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster)
			{
				Moderators.Instance.RemoveModerator(ctx.ArgString(0));
			}
		}
	}
	internal sealed class StartCountdownCommand : ICommandHandler
	{
		internal const string WireName = "StartCountdown";

		public string Name => "StartCountdown";

		public int MinArgs => 1;

		public bool HostOnly => false;

		public void Execute(CommandContext ctx)
		{
			if (ctx.SenderIsMaster)
			{
				int result;
				int seconds = (int.TryParse(ctx.ArgString(0), out result) ? result : 5);
				StartCountdown.BeginDisplayOnly(seconds);
			}
		}
	}
	internal sealed class StartGameCommand : ICommandHandler
	{
		internal const string WireName = "StartGame";

		public string Name => "StartGame";

		public int MinArgs => 0;

		public bool HostOnly => true;

		public void Execute(CommandContext ctx)
		{
			Plugin.Logger.LogInfo((object)"Network event: StartGame command received.");
			AuditEvents.StartGameRequest(ctx.SenderName, ctx.SenderSteamId);
			StartCountdown.BeginHostAuthoritative(ModConfig.StartCountdownSeconds.Value);
		}
	}
}
namespace SharePermissions.Core
{
	internal static class RamVerbs
	{
		internal const string Kill = "kill";

		internal const string Heal = "heal";

		internal const string Revive = "revive";

		internal const string Crown = "crown";

		internal const string Truck = "truck";

		internal const string TeleportTo = "tpto";

		internal const string Summon = "summon";

		internal const string Item = "item";

		internal const string Valuable = "valuable";

		internal const string Enemy = "enemy";

		internal const string Level = "level";

		internal const string MapOn = "mapon";

		internal const string MapOff = "mapoff";

		internal const string ExtractDiscover = "extdiscover";

		internal const string ExtractComplete = "extcomplete";

		internal const string LevelsCompleted = "levelsdone";

		internal const string Money = "money";

		internal static string Describe(string verb)
		{
			return verb switch
			{
				"kill" => "Kill player", 
				"heal" => "Heal player", 
				"revive" => "Revive player", 
				"crown" => "Give crown", 
				"truck" => "Return player to truck", 
				"tpto" => "Teleport to player", 
				"summon" => "Summon player", 
				"item" => "Spawn item", 
				"valuable" => "Spawn valuable", 
				"enemy" => "Spawn enemy", 
				"level" => "Change level", 
				"mapon" => "Enable map", 
				"mapoff" => "Disable map", 
				"extdiscover" => "Discover extraction point", 
				"extcomplete" => "Complete extraction point", 
				"levelsdone" => "Set level count", 
				"money" => "Set money", 
				_ => "Unknown action", 
			};
		}
	}
	internal static class AdminMenuActions
	{
		private const BindingFlags AnyStatic = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;

		private static bool resolved;

		private static MethodInfo? killPlayer;

		private static MethodInfo? revivePlayer;

		private static MethodInfo? healPlayer;

		private static MethodInfo? giveCrown;

		private static MethodInfo? returnToTruck;

		private static MethodInfo? teleportPair;

		private static MethodInfo? getItems;

		private static readonly MethodInfo?[] ValuableGetters = new MethodInfo[7];

		private static MethodInfo? getEnemies;

		private static MethodInfo? getModEnemies;

		private static MethodInfo? getMaps;

		private static MethodInfo? getArenas;

		private static MethodInfo? getShops;

		private static MethodInfo? repoSpawnItem;

		private static MethodInfo? repoSpawnValuable;

		private static MethodInfo? repoSpawnEnemy;

		internal static MethodInfo? SpawnItemMethod { get; private set; }

		internal static MethodInfo? SpawnValuableMethod { get; private set; }

		internal static MethodInfo? SpawnEnemyMethod { get; private set; }

		internal static MethodInfo? KickPlayerMethod { get; private set; }

		internal static MethodInfo? BanPlayerMethod { get; private set; }

		internal static MethodInfo? SetMapEnabledMethod { get; private set; }

		internal static MethodInfo? ChangeLevelMethod { get; private set; }

		internal static MethodInfo? DiscoverNextMethod { get; private set; }

		internal static MethodInfo? CompleteExtractionMethod { get; private set; }

		internal static MethodInfo? AddIntSliderMethod { get; private set; }

		internal static MethodInfo? TeleportToMethod { get; private set; }

		internal static MethodInfo? SummonMethod { get; private set; }

		internal static MethodInfo? KillPlayerMethod => killPlayer;

		internal static MethodInfo? HealPlayerMethod => healPlayer;

		internal static MethodInfo? RevivePlayerMethod => revivePlayer;

		internal static MethodInfo? GiveCrownMethod => giveCrown;

		internal static MethodInfo? ReturnToTruckMethod => returnToTruck;

		internal static bool PlayerActionsAvailable { get; private set; }

		internal static bool SpawnAvailable { get; private set; }

		internal static bool MapAvailable { get; private set; }

		internal static void Resolve()
		{
			if (resolved)
			{
				return;
			}
			resolved = true;
			try
			{
				Type type = AdminMenuBridge.FindType("RepoAdminMenu.Utils.PlayerUtil");
				Type type2 = AdminMenuBridge.FindType("RepoAdminMenu.Utils.ItemUtil");
				Type type3 = AdminMenuBridge.FindType("RepoAdminMenu.Utils.ValuableUtil");
				Type type4 = AdminMenuBridge.FindType("RepoAdminMenu.Utils.EnemyUtil");
				Type type5 = AdminMenuBridge.FindType("RepoAdminMenu.Utils.MapUtil");
				Type type6 = AdminMenuBridge.FindType("RepoAdminMenu.Utils.ExtractionPointUtil");
				Type type7 = AdminMenuBridge.FindType("RepoAdminMenu.Menu");
				Type[] types = new Type[1] { typeof(PlayerAvatar) };
				killPlayer = type?.GetMethod("killPlayer", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
				revivePlayer = type?.GetMethod("revivePlayer", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
				healPlayer = type?.GetMethod("healPlayer", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
				giveCrown = type?.GetMethod("giveCrown", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
				returnToTruck = type?.GetMethod("returnToTruck", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
				TeleportToMethod = type?.GetMethod("teleportTo", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
				SummonMethod = type?.GetMethod("summon", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
				KickPlayerMethod = type?.GetMethod("KickPlayer", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
				BanPlayerMethod = type?.GetMethod("BanPlayer", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
				teleportPair = type?.GetMethod("teleport", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[2]
				{
					typeof(PlayerAvatar),
					typeof(PlayerAvatar)
				}, null);
				getItems = type2?.GetMethod("getItems", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				SpawnItemMethod = type2?.GetMethod("spawnItem", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				string[] array = new string[7] { "Tiny", "Small", "Medium", "Big", "Wide", "Tall", "VeryTall" };
				for (int i = 0; i < array.Length; i++)
				{
					ValuableGetters[i] = type3?.GetMethod("get" + array[i] + "Valuables", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				}
				SpawnValuableMethod = type3?.GetMethod("spawnValuable", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				getEnemies = type4?.GetMethod("getEnemies", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				getModEnemies = type4?.GetMethod("getModEnemies", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				SpawnEnemyMethod = type4?.GetMethod("spawnEnemy", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
				getMaps = type5?.GetMethod("getMaps", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				getArenas = type5?.GetMethod("getArenas", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				getShops = type5?.GetMethod("getShops", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				ChangeLevelMethod = type5?.GetMethod("changeLevel", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				SetMapEnabledMethod = type5?.GetMethod("setMapEnabled", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				DiscoverNextMethod = type6?.GetMethod("discoverNext", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				CompleteExtractionMethod = type6?.GetMethod("complete", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				AddIntSliderMethod = type7?.GetMethod("addIntSlider", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				ResolveRepoLib();
				PlayerActionsAvailable = killPlayer != null && revivePlayer != null && healPlayer != null && giveCrown != null && returnToTruck != null && teleportPair != null && TeleportToMethod != null && SummonMethod != null;
				SpawnAvailable = getItems != null && getEnemies != null && getModEnemies != null && SpawnItemMethod != null && SpawnValuableMethod != null && SpawnEnemyMethod != null && repoSpawnItem != null && repoSpawnValuable != null && repoSpawnEnemy != null && Array.TrueForAll(ValuableGetters, (MethodInfo g) => g != null);
				MapAvailable = getMaps != null && getArenas != null && getShops != null && ChangeLevelMethod != null && SetMapEnabledMethod != null && DiscoverNextMethod != null && CompleteExtractionMethod != null;
				Plugin.Logger.LogInfo((object)("Admin Menu action proxy: player actions " + OnOff(PlayerActionsAvailable) + ", spawning " + OnOff(SpawnAvailable) + ", map " + OnOff(MapAvailable)));
			}
			catch (Exception ex)
			{
				bool num = (MapAvailable = false);
				SpawnAvailable = num;
				PlayerActionsAvailable = num;
				Plugin.Logger.LogWarning((object)("Admin Menu action resolution failed (" + ex.GetType().Name + ": " + ex.Message + ") - action proxy unavailable"));
			}
		}

		private static string OnOff(bool on)
		{
			if (!on)
			{
				return "unavailable";
			}
			return "available";
		}

		private static void ResolveRepoLib()
		{
			Type type = AdminMenuBridge.FindType("REPOLib.Modules.Items");
			Type type2 = AdminMenuBridge.FindType("REPOLib.Modules.Valuables");
			Type type3 = AdminMenuBridge.FindType("REPOLib.Modules.Enemies");
			repoSpawnItem = FindByArity(type, "SpawnItem", 3);
			repoSpawnValuable = FindByArity(type2, "SpawnValuable", 3);
			repoSpawnEnemy = FindByArity(type3, "SpawnEnemy", 4);
		}

		private static MethodInfo? FindByArity(Type? type, string name, int parameterCount)
		{
			if (type == null)
			{
				return null;
			}
			MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.Name == name && methodInfo.GetParameters().Length == parameterCount)
				{
					return methodInfo;
				}
			}
			return null;
		}

		internal static bool Execute(string verb, string arg, PlayerAvatar requester)
		{
			switch (verb)
			{
			case "kill":
				return InvokeOnTarget(killPlayer, arg);
			case "heal":
				return InvokeOnTarget(healPlayer, arg);
			case "revive":
				return InvokeOnTarget(revivePlayer, arg);
			case "crown":
				return InvokeOnTarget(giveCrown, arg);
			case "truck":
				return InvokeOnTarget(returnToTruck, arg);
			case "tpto":
				return Teleport(requester, ResolveTarget(arg));
			case "summon":
				return Teleport(ResolveTarget(arg), requester);
			case "item":
				return SpawnItem(arg, requester);
			case "valuable":
				return SpawnValuable(arg, requester);
			case "enemy":
				return SpawnEnemy(arg, requester);
			case "level":
				return ChangeLevel(arg);
			case "mapon":
				return SetMapEnabled(arg, enabled: true);
			case "mapoff":
				return SetMapEnabled(arg, enabled: false);
			case "extdiscover":
				if (MapAvailable)
				{
					return Invoke(DiscoverNextMethod);
				}
				return false;
			case "extcomplete":
				if (MapAvailable)
				{
					return Invoke(CompleteExtractionMethod);
				}
				return false;
			case "levelsdone":
				return SetLevelsCompleted(arg);
			case "money":
				return SetMoney(arg);
			default:
				Plugin.Logger.LogWarning((object)("Unknown admin menu action verb: " + Sanitize(verb)));
				return false;
			}
		}

		private static string Sanitize(string s)
		{
			char[] array = new char[Math.Min(s.Length, 32)];
			int num = 0;
			foreach (char c in s)
			{
				if (num == array.Length)
				{
					break;
				}
				if (!char.IsControl(c))
				{
					array[num++] = c;
				}
			}
			return new string(array, 0, num);
		}

		private static PlayerAvatar? ResolveTarget(string steamId)
		{
			if (string.IsNullOrEmpty(steamId))
			{
				return null;
			}
			PlayerAvatar val = SemiFunc.PlayerGetFromSteamID(steamId);
			if (!((Object)(object)val == (Object)null))
			{
				return val;
			}
			return null;
		}

		private static bool InvokeOnTarget(MethodInfo? method, string steamId)
		{
			if (!PlayerActionsAvailable || method == null)
			{
				return false;
			}
			PlayerAvatar val = ResolveTarget(steamId);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			return Invoke(method, val);
		}

		private static bool Teleport(PlayerAvatar? from, PlayerAvatar? to)
		{
			if (!PlayerActionsAvailable || (Object)(object)from == (Object)null || (Object)(object)to == (Object)null)
			{
				return false;
			}
			return Invoke(teleportPair, from, to);
		}

		private static Vector3 SpawnPointFor(PlayerAvatar requester)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: 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)
			Transform transform = ((Component)requester).transform;
			return transform.position + new Vector3(0f, 1f, 0f) + transform.forward;
		}

		private static bool SpawnItem(string key, PlayerAvatar requester)
		{
			//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)
			if (!SpawnAvailable)
			{
				return false;
			}
			object obj = Lookup(getItems, key);
			if (obj == null)
			{
				return false;
			}
			return Invoke(repoSpawnItem, obj, SpawnPointFor(requester), Quaternion.identity);
		}

		private static bool SpawnValuable(string key, PlayerAvatar requester)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!SpawnAvailable)
			{
				return false;
			}
			MethodInfo[] valuableGetters = ValuableGetters;
			foreach (MethodInfo getter in valuableGetters)
			{
				object obj = Lookup(getter, key);
				if (obj != null)
				{
					return Invoke(repoSpawnValuable, obj, SpawnPointFor(requester), Quaternion.identity);
				}
			}
			return false;
		}

		private static bool SpawnEnemy(string key, PlayerAvatar requester)
		{
			//IL_0040: 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)
			if (!SpawnAvailable)
			{
				return false;
			}
			object obj = Lookup(getEnemies, key) ?? Lookup(getModEnemies, key);
			if (obj == null)
			{
				return false;
			}
			return Invoke(repoSpawnEnemy, obj, ((Component)requester).transform.position, Quaternion.identity, false);
		}

		private static bool ChangeLevel(string name)
		{
			if (!MapAvailable)
			{
				return false;
			}
			object obj = ResolveLevel(name);
			if (obj == null)
			{
				return false;
			}
			return Invoke(ChangeLevelMethod, obj);
		}

		private static bool SetMapEnabled(string name, bool enabled)
		{
			if (!MapAvailable)
			{
				return false;
			}
			object obj = Lookup(getMaps, name);
			if (obj == null)
			{
				return false;
			}
			return Invoke(SetMapEnabledMethod, obj, enabled);
		}

		internal static object? ResolveLevel(string name)
		{
			object obj = Lookup(getMaps, name) ?? Lookup(getArenas, name) ?? Lookup(getShops, name);
			if (obj != null)
			{
				return obj;
			}
			Level val = RunManager.instance?.levelLobby;
			if ((Object)(object)val != (Object)null && LevelKey((Object)(object)val) == name)
			{
				return val;
			}
			return null;
		}

		internal static string LevelKey(Object level)
		{
			return level.name.Replace("Level - ", string.Empty);
		}

		private static bool TryParseInt(string raw, out int value)
		{
			return int.TryParse(raw, NumberStyles.Integer, CultureInfo.InvariantCulture, out value);
		}

		private static bool SetLevelsCompleted(string raw)
		{
			if (!MapAvailable || !TryParseInt(raw, out var value))
			{
				return false;
			}
			RunManager instance = RunManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			instance.levelsCompleted = value;
			return true;
		}

		private static bool SetMoney(string raw)
		{
			if (!MapAvailable || !TryParseInt(raw, out var value))
			{
				return false;
			}
			PunManager instance = PunManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			instance.SetRunStatSet("currency", value);
			return true;
		}

		private static object? Lookup(MethodInfo? getter, string key)
		{
			if (getter == null || string.IsNullOrEmpty(key))
			{
				return null;
			}
			try
			{
				if (!(getter.Invoke(null, Array.Empty<object>()) is IDictionary dictionary))
				{
					return null;
				}
				return dictionary.Contains(key) ? dictionary[key] : null;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("Admin Menu lookup failed (" + ex.GetType().Name + ": " + ex.Message + ")"));
				return null;
			}
		}

		private static bool Invoke(MethodInfo? method, params object?[] args)
		{
			if (method == null)
			{
				return false;
			}
			try
			{
				method.Invoke(null, args);
				return true;
			}
			catch (Exception ex)
			{
				Exception ex2 = (ex as TargetInvocationException)?.InnerException ?? ex;
				Plugin.Logger.LogWarning((object)("Admin Menu action " + method.Name + " failed (" + ex2.GetType().Name + ": " + ex2.Message + ")"));
				return false;
			}
		}
	}
	internal static class AdminMenuBridge
	{
		internal const string AdminMenuGuid = "proferabg.REPO.RepoAdminMenu";

		private const string SettingsTypeName = "RepoAdminMenu.Settings";

		private const string MenuTypeName = "RepoAdminMenu.Menu";

		private const string ChatPatchTypeName = "RepoAdminMenu.ChatManagerPatch";

		private static bool resolved;

		private static PropertyInfo? settingsInstanceProp;

		private static FieldInfo? settingsInstanceField;

		private static MethodInfo? toJsonMethod;

		private static MethodInfo? loadFromJsonMethod;

		internal static MethodInfo? UpdateClientsMethod { get; private set; }

		internal static MethodInfo? ToggleMenuMethod { get; private set; }

		internal static MethodInfo? ChatMessageSendPrefixMethod { get; private set; }

		internal static bool IsAvailable
		{
			get
			{
				Resolve();
				if (UpdateClientsMethod != null)
				{
					return ToggleMenuMethod != null;
				}
				return false;
			}
		}

		internal static string? GetSettingsJson()
		{
			Resolve();
			if (toJsonMethod == null)
			{
				return null;
			}
			try
			{
				object obj = settingsInstanceField?.GetValue(null) ?? settingsInstanceProp?.GetValue(null);
				if (obj == null)
				{
					return null;
				}
				return toJsonMethod.Invoke(obj, Array.Empty<object>()) as string;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("Admin Menu toJson failed (" + ex.GetType().Name + ": " + ex.Message + ")"));
				return null;
			}
		}

		internal static bool ApplySettingsJson(string json)
		{
			Resolve();
			if (loadFromJsonMethod == null)
			{
				return false;
			}
			try
			{
				loadFromJsonMethod.Invoke(null, new object[1] { json });
				return true;
			}
			catch (Exception ex)
			{
				Exception ex2 = (ex as TargetInvocationException)?.InnerException ?? ex;
				Plugin.Logger.LogWarning((object)("Admin Menu loadFromJson failed (" + ex2.GetType().Name + ": " + ex2.Message + ")"));
				return false;
			}
		}

		internal static bool BroadcastSettings()
		{
			Resolve();
			if (UpdateClientsMethod == null)
			{
				return false;
			}
			try
			{
				UpdateClientsMethod.Invoke(null, Array.Empty<object>());
				return true;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("Admin Menu UpdateClients failed (" + ex.GetType().Name + ": " + ex.Message + ")"));
				return false;
			}
		}

		private static void Resolve()
		{
			if (resolved)
			{
				return;
			}
			resolved = true;
			try
			{
				Type type = FindType("RepoAdminMenu.Settings");
				if (type == null)
				{
					Plugin.Logger.LogInfo((object)"Admin Menu not detected - moderator admin-menu grant unavailable");
					return;
				}
				settingsInstanceField = type.GetField("instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				settingsInstanceProp = type.GetProperty("instance", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				toJsonMethod = type.GetMethod("toJson", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				loadFromJsonMethod = type.GetMethod("loadFromJson", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, new Type[1] { typeof(string) }, null);
				UpdateClientsMethod = type.GetMethod("UpdateClients", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				ToggleMenuMethod = FindType("RepoAdminMenu.Menu")?.GetMethod("toggleMenu", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic, null, Type.EmptyTypes, null);
				ChatMessageSendPrefixMethod = FindType("RepoAdminMenu.ChatManagerPatch")?.GetMethod("MessageSend_Prefix", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				string text = FirstMissingMember();
				if (text != null)
				{
					Plugin.Logger.LogWarning((object)("Admin Menu found but " + text + " is missing (API change?) - moderator admin-menu grant unavailable"));
					UpdateClientsMethod = null;
					ToggleMenuMethod = null;
				}
				else
				{
					Plugin.Logger.LogInfo((object)"Admin Menu detected - moderator admin-menu grant enabled");
				}
			}
			catch (Exception ex)
			{
				UpdateClientsMethod = null;
				ToggleMenuMethod = null;
				Plugin.Logger.LogWarning((object)("Admin Menu detection failed (" + ex.GetType().Name + ": " + ex.Message + ") - moderator admin-menu grant unavailable"));
			}
		}

		private static string? FirstMissingMember()
		{
			if (settingsInstanceField == null && settingsInstanceProp == null)
			{
				return "Settings.instance";
			}
			if (toJsonMethod == null)
			{
				return "Settings.toJson()";
			}
			if (loadFromJsonMethod == null)
			{
				return "Settings.loadFromJson(string)";
			}
			if (UpdateClientsMethod == null)
			{
				return "Settings.UpdateClients()";
			}
			if (ToggleMenuMethod == null)
			{
				return "Menu.toggleMenu()";
			}
			return null;
		}

		internal static Type? FindType(string typeName)
		{
			if (Chainloader.PluginInfos.TryGetValue("proferabg.REPO.RepoAdminMenu", out var value) && (Object)(object)((value != null) ? value.Instance : null) != (Object)null)
			{
				Type type = ((object)value.Instance).GetType().Assembly.GetType(typeName, throwOnError: false);
				if (type != null)
				{
					return type;
				}
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					Type type2 = assembly.GetType(typeName, throwOnError: false);
					if (type2 != null)
					{
						return type2;
					}
				}
				catch
				{
				}
			}
			return null;
		}
	}
	internal static class AnnounceText
	{
		internal const int MaxChars = 120;

		internal static string Sanitize(string? raw)
		{
			string source = MenuUiHelpers.StripRichText(raw);
			source = new string(source.Where((char c) => c != '<' && c != '>' && c != '[' && c != ']').ToArray());
			source = source.Trim();
			return MenuUiHelpers.TruncateSafe(source, 120);
		}
	}
	internal enum PBanOutcome
	{
		None,
		Recorded,
		Failed
	}
	internal static class AuditEvents
	{
		internal static void PlayerKickBan(bool ban, string targetName, string steamId, int actor, bool targetIsModerator, PBanOutcome pban = PBanOutcome.None)
		{
			AuditLog.Write("Player " + (ban ? "banned" : "kicked") + ": " + targetName + " (" + steamId + ") by host" + MetaTail(ActorPair(actor), TargetRolePair(targetIsModerator), PBanPair(pban)), ban ? "ban" : "kick");
		}

		internal static void KickBanRequest(bool ban, string targetName, string steamId, int actor, bool targetIsModerator, string senderName, string senderSteamId, PBanOutcome pban = PBanOutcome.None)
		{
			AuditLog.Write((ban ? "Ban" : "Kick") + " request " + targetName + " (" + steamId + ") from player:" + senderName + "(" + senderSteamId + ")" + MetaTail(ActorPair(actor), TargetRolePair(targetIsModerator), PBanPair(pban)), ban ? "ban" : "kick");
		}

		internal static void GhostKickBan(bool ban, int actorNumber, string? ghostName, string? ghostSteamId, string? senderName = null, string? senderSteamId = null, PBanOutcome pban = PBanOutcome.None)
		{
			string text = ((senderName == null) ? "by host" : ("by: " + senderName + " (" + senderSteamId + ")"));
			AuditLog.Write(string.Format("Ghost player {0} (ActorNumber: {1}, Name: {2}, ", ban ? "banned" : "kicked", actorNumber, ghostName) + "SteamID: " + (string.IsNullOrEmpty(ghostSteamId) ? "unknown" : ghostSteamId) + ") " + text + MetaTail(PBanPair(pban)), ban ? "ghostban" : "ghostkick");
		}

		internal static void RpcFloodAutoKick(string name, int actorNumber, string? steamId, string reason)
		{
			AuditLog.Write(string.Format("RPC flood: {0} (actor {1}, SteamID: {2}) {3} - auto-kicked", name, actorNumber, steamId ?? "unknown", reason) + MetaTail(), "flood");
		}

		internal static void ModeratorGranted(string name, string steamId)
		{
			AuditLog.Write("Moderator granted to " + name + " (" + steamId + ") by host" + MetaTail(), "grant");
		}

		internal static void ModeratorRevoked(string name, string steamId)
		{
			AuditLog.Write("Moderator revoked from " + name + " (" + steamId + ") by host" + MetaTail(), "revoke");
		}

		internal static void TokenRevoked(string tokenPrefix)
		{
			AuditLog.Write("Moderator token revoked (" + tokenPrefix + ") by host" + MetaTail(), "revoke");
		}

		internal static void StartGameRequest(string senderName, string senderSteamId)
		{
			AuditLog.Write("Start game request from player:" + senderName + "(" + senderSteamId + ")" + MetaTail(), "start");
		}

		internal static void CountdownBegun(int seconds)
		{
			AuditLog.Write($"Run start countdown begun ({seconds}s)", "start");
		}

		internal static void CountdownCancelled(string cancelledBy)
		{
			AuditLog.Write("Run start countdown cancelled by " + cancelledBy, "start");
		}

		internal static void CountdownCancelledPlayerJoining()
		{
			AuditLog.Write("Run start countdown cancelled (a player is joining)", "start");
		}

		internal static void RunStarted()
		{
			AuditLog.Write("Run started", "none");
		}

		internal static void AdminMenuSettingsChanged(string senderName, string senderSteamId, int actor)
		{
			AuditLog.Write("Admin menu settings changed from player:" + senderName + "(" + senderSteamId + ")" + MetaTail(ActorPair(actor)), "none");
		}

		internal static void AdminMenuAction(string action, string senderName, string senderSteamId, int actor, string? targetSteamId = null)
		{
			AuditLog.Write("Admin menu action: " + action + " from player:" + senderName + "(" + senderSteamId + ")" + MetaTail(ActorPair(actor), TargetIdPair(targetSteamId)), "none");
		}

		internal static void BackToLobbyRequest(string senderName, string senderSteamId)
		{
			AuditLog.Write("Return to lobby request from player:" + senderName + "(" + senderSteamId + ")" + MetaTail(), "lobby");
		}

		internal static void Announcement(string text)
		{
			AuditLog.Write("Announcement: " + text + " by host" + MetaTail(), "none");
		}

		internal static void PrivateVoiceOpened()
		{
			AuditLog.Write("Private voice channel opened by host" + MetaTail());
		}

		internal static void PrivateVoiceClosed()
		{
			AuditLog.Write("Private voice channel closed by host" + MetaTail());
		}

		internal static void PrivateVoiceRotated()
		{
			AuditLog.Write("Private voice channel key rotated by host" + MetaTail());
		}

		private static string? ActorPair(int actor)
		{
			if (actor <= 0)
			{
				return null;
			}
			return $"Actor: {actor}";
		}

		private static string? TargetIdPair(string? steamId)
		{
			if (string.IsNullOrEmpty(steamId))
			{
				return null;
			}
			foreach (char c in steamId)
			{
				if (!char.IsDigit(c))
				{
					return null;
				}
			}
			return "Target: " + steamId;
		}

		private static string? TargetRolePair(bool isModerator)
		{
			if (!isModerator)
			{
				return null;
			}
			return "Target role: Moderator";
		}

		private static string? PBanPair(PBanOutcome pban)
		{
			return pban switch
			{
				PBanOutcome.Recorded => "Ban: Persistent", 
				PBanOutcome.Failed => "Ban: Persistent - record failed", 
				_ => null, 
			};
		}

		private static string MetaTail(params string?[] pairs)
		{
			List<string> list = new List<string>(pairs.Length + 2);
			foreach (string text in pairs)
			{
				if (!string.IsNullOrEmpty(text))
				{
					list.Add(text);
				}
			}
			try
			{
				Room currentRoom = PhotonNetwork.CurrentRoom;
				if (currentRoom != null)
				{
					list.Add($"Players: {currentRoom.PlayerCount}");
				}
				list.Add("Stage: " + StageName());
			}
			catch
			{
			}
			if (list.Count != 0)
			{
				return " [" + string.Join(" | ", list) + "]";
			}
			return "";
		}

		private static string StageName()
		{
			if (SemiFunc.RunIsLobbyMenu())
			{
				return "Lobby";
			}
			if (SemiFunc.MenuLevel())
			{
				return "Menu";
			}
			if (SemiFunc.RunIsLobby())
			{
				return "Truck";
			}
			return "In level";
		}
	}
	internal static class AuditLog
	{
		private static string? logPath;

		private const int BufferLimit = 100;

		private static readonly Queue<string> buffer = new Queue<string>();

		private const int MaxLineLength = 500;

		private static string LogPath
		{
			get
			{
				if (!string.IsNullOrEmpty(logPath))
				{
					return logPath;
				}
				try
				{
					logPath = Path.Combine(Paths.ConfigPath, "sharepermissions.log");
				}
				catch
				{
					logPath = Path.Combine(Application.persistentDataPath, "sharepermissions.log");
				}
				return logPath;
			}
		}

		internal static event Action<string, string>? EntryWritten;

		private static string Sanitize(string? line)
		{
			if (string.IsNullOrEmpty(line))
			{
				return "";
			}
			StringBuilder stringBuilder = new StringBuilder(line.Length);
			foreach (char c in line)
			{
				stringBuilder.Append(char.IsControl(c) ? ' ' : c);
			}
			string text = stringBuilder.ToString();
			if (text.Length <= 500)
			{
				return text;
			}
			return text.Substring(0, 500);
		}

		internal static void Write(string line, string kind = "info")
		{
			line = Sanitize(line);
			DateTime now = DateTime.Now;
			string text = $"[{now:HH:mm:ss}] {line}";
			AppendToBuffer(text);
			AuditStore.TryAppend(text);
			if (ModConfig.WriteForensicLog.Value)
			{
				try
				{
					string directoryName = Path.GetDirectoryName(LogPath);
					if (!string.IsNullOrEmpty(directoryName) && !Directory.Exists(directoryName))
					{
						Directory.CreateDirectory(directoryName);
					}
					File.AppendAllText(LogPath, $"[{now:yyyy-MM-dd HH:mm:ss}] {line}" + Environment.NewLine);
				}
				catch (Exception arg)
				{
					Plugin.Logger.LogError((object)$"[SharePermissions] Log save failed: {arg}");
				}
			}
			Action<string, string> entryWritten = AuditLog.EntryWritten;
			if (entryWritten == null)
			{
				return;
			}
			Delegate[] invocationList = entryWritten.GetInvocationList();
			for (int i = 0; i < invocationList.Length; i++)
			{
				Action<string, string> action = (Action<string, string>)invocationList[i];
				try
				{
					action(text, kind);
				}
				catch (Exception arg2)
				{
					Plugin.Logger.LogError((object)$"[SharePermissions] Audit EntryWritten subscriber failed: {arg2}");
				}
			}
		}

		internal static void AddSynced(string entry)
		{
			entry = Sanitize(entry);
			AppendToBuffer(entry);
			AuditStore.TryAppend(entry);
		}

		internal static IReadOnlyList<string> GetEntries()
		{
			return buffer.ToArray();
		}

		internal static void Clear()
		{
			buffer.Clear();
		}

		private static void AppendToBuffer(string entry)
		{
			buffer.Enqueue(entry);
			while (buffer.Count > 100)
			{
				buffer.Dequeue();
			}
		}
	}
	internal static class AuditStore
	{
		[Serializable]
		private sealed class Line
		{
			public string t = "";

			public string k = "";
		}

		private const int MaxSnapshot = 500;

		private static string? storePath;

		private static readonly List<(string Display, string Key)> past = new List<(string, string)>();

		private static readonly HashSet<string> knownKeys = new HashSet<string>();

		private static bool loaded;

		private static string StorePath
		{
			get
			{
				if (!string.IsNullOrEmpty(storePath))
				{
					return storePath;
				}
				try
				{
					storePath = Path.Combine(Paths.ConfigPath, "sharepermissions-history.jsonl");
				}
				catch
				{
					storePath = Path.Combine(Application.persistentDataPath, "sharepermissions-history.jsonl");
				}
				return storePath;
			}
		}

		internal static void Init()
		{
			if (loaded)
			{
				return;
			}
			loaded = true;
			try
			{
				if (!File.Exists(StorePath))
				{
					return;
				}
				List<(DateTime, string)> list = new List<(DateTime, string)>();
				HashSet<string> hashSet = new HashSet<string>();
				int num = 0;
				string[] array = File.ReadAllLines(StorePath);
				foreach (string text in array)
				{
					if (!string.IsNullOrWhiteSpace(text))
					{
						num++;
						Line line = null;
						try
						{
							line = JsonUtility.FromJson<Line>(text);
						}
						catch
						{
						}
						if (line != null && !string.IsNullOrEmpty(line.k) && hashSet.Add(line.k))
						{
							DateTime.TryParse(line.t, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var result);
							list.Add((result, line.k));
						}
					}
				}
				int num2 = Math.Max(0, list.Count - 500);
				for (int j = num2; j < list.Count; j++)
				{
					knownKeys.Add(list[j].Item2);
					past.Add((DisplayOf(list[j].Item1, list[j].Item2), list[j].Item2));
				}
				if (past.Count > 0)
				{
					Plugin.Logger.LogInfo((object)$"[SharePermissions] Loaded {past.Count} persisted history entries");
				}
				if (ModConfig.PersistHistory.Value && num > 1000)
				{
					Compact(list.GetRange(num2, list.Count - num2));
				}
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[SharePermissions] History snapshot load failed: " + ex.Message));
			}
		}

		internal static void TryAppend(string entry)
		{
			try
			{
				if (ModConfig.PersistHistory.Value && knownKeys.Add(entry))
				{
					string text = JsonUtility.ToJson((object)new Line
					{
						t = EventTimeOf(entry).ToString("o", CultureInfo.InvariantCulture),
						k = entry
					});
					File.AppendAllText(StorePath, text + Environment.NewLine);
				}
			}
			catch (Exception arg)
			{
				knownKeys.Remove(entry);
				Plugin.Logger.LogError((object)$"[SharePermissions] History persist failed: {arg}");
			}
		}

		private static DateTime EventTimeOf(string entry)
		{
			DateTime now = DateTime.Now;
			int num = entry.IndexOf(']');
			if (num > 1 && TimeSpan.TryParseExact(entry.Substring(1, num - 1), "hh\\:mm\\:ss", CultureInfo.InvariantCulture, out var result))
			{
				DateTime dateTime = now.Date + result;
				if (dateTime > now.AddHours(12.0))
				{
					dateTime = dateTime.AddDays(-1.0);
				}
				return dateTime;
			}
			return now;
		}

		private static void Compact(List<(DateTime T, string K)> keep)
		{
			try
			{
				string text = StorePath + ".tmp";
				List<string> list = new List<string>(keep.Count);
				foreach (var (dateTime, k) in keep)
				{
					list.Add(JsonUtility.ToJson((object)new Line
					{
						t = dateTime.ToString("o", CultureInfo.InvariantCulture),
						k = k
					}));
				}
				File.WriteAllLines(text, list);
				try
				{
					File.Replace(text, StorePath, null);
				}
				catch
				{
					if (File.Exists(StorePath))
					{
						File.Delete(StorePath);
					}
					File.Move(text, StorePath);
				}
				Plugin.Logger.LogInfo((object)$"[SharePermissions] Compacted history store to {list.Count} entries");
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("[SharePermissions] History compaction skipped: " + ex.Message));
				try
				{
					if (File.Exists(StorePath + ".tmp"))
					{
						File.Delete(StorePath + ".tmp");
					}
				}
				catch
				{
				}
			}
		}

		internal static List<string> PastEntries(int maxCount, ICollection<string> excludeKeys)
		{
			List<string> list = new List<string>();
			if (maxCount <= 0)
			{
				return list;
			}
			int num = past.Count - 1;
			while (num >= 0 && list.Count < maxCount)
			{
				if (!excludeKeys.Contains(past[num].Key))
				{
					list.Add(past[num].Display);
				}
				num--;
			}
			list.Reverse();
			return list;
		}

		internal static void ClearAll()
		{
			try
			{
				if (File.Exists(StorePath))
				{
					File.Delete(StorePath);
				}
			}
			catch
			{
				try
				{
					File.WriteAllText(StorePath, "");
				}
				catch (Exception arg)
				{
					Plugin.Logger.LogError((object)$"[SharePermissions] History clear failed: {arg}");
					return;
				}
			}
			past.Clear();
			knownKeys.Clear();
		}

		private static string DisplayOf(DateTime t, string key)
		{
			if (t == default(DateTime))
			{
				return key;
			}
			int num = key.IndexOf("] ", StringComparison.Ordinal);
			string arg = ((num >= 0) ? key.Substring(num + 2) : key);
			return $"[{t:MM-dd HH:mm}] {arg}";
		}
	}
	internal static class BanEnforcerBridge
	{
		private const string BanEnforcerGuid = "com.empress.repo.banenforcer";

		private const string ApiTypeName = "Empress.REPO.BanEnforcer.VippyBan";

		private static bool resolved;

		private static MethodInfo? banMethod;

		internal static bool IsAvailable
		{
			get
			{
				Resolve();
				return banMethod != null;
			}
		}

		internal static bool TryBan(ulong steamId, string reason, string displayName)
		{
			Resolve();
			if (banMethod == null)
			{
				return false;
			}
			try
			{
				object obj = banMethod.Invoke(null, new object[3] { steamId, reason, displayName });
				return obj is bool && (bool)obj;
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)$"BanEnforcer Ban({steamId}) failed ({ex.GetType().Name}: {ex.Message})");
				return false;
			}
		}

		private static void Resolve()
		{
			if (resolved)
			{
				return;
			}
			resolved = true;
			try
			{
				Type type = FindApiType();
				if (type == null)
				{
					Plugin.Logger.LogInfo((object)"BanEnforcer not detected - Ban (persistent) unavailable");
					return;
				}
				banMethod = type.GetMethod("Ban", BindingFlags.Static | BindingFlags.Public, null, new Type[3]
				{
					typeof(ulong),
					typeof(string),
					typeof(string)
				}, null);
				if (banMethod == null)
				{
					Plugin.Logger.LogWarning((object)"BanEnforcer found but Empress.REPO.BanEnforcer.VippyBan.Ban(ulong, string, string) is missing (API change?) - Ban (persistent) unavailable");
				}
				else
				{
					Plugin.Logger.LogInfo((object)"BanEnforcer detected - Ban (persistent) enabled");
				}
			}
			catch (Exception ex)
			{
				banMethod = null;
				Plugin.Logger.LogWarning((object)("BanEnforcer detection failed (" + ex.GetType().Name + ": " + ex.Message + ") - Ban (persistent) unavailable"));
			}
		}

		private static Type? FindApiType()
		{
			if (Chainloader.PluginInfos.TryGetValue("com.empress.repo.banenforcer", out var value) && (Object)(object)((value != null) ? value.Instance : null) != (Object)null)
			{
				Type type = ((object)value.Instance).GetType().Assembly.GetType("Empress.REPO.BanEnforcer.VippyBan", throwOnError: false);
				if (type != null)
				{
					return type;
				}
			}
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				try
				{
					Type type2 = assembly.GetType("Empress.REPO.BanEnforcer.VippyBan", throwOnError: false);
					if (type2 != null)
					{
						return type2;
					}
				}
				catch
				{
				}
			}
			return null;
		}
	}
	internal static class GameActions
	{
		private const byte KickEventCode = 123;

		private const byte BanEventCode = 124;

		internal static bool PendingLobbyReturn;

		internal static void ReturnToLobby()
		{
			if (SemiFunc.MenuLevel())
			{
				Plugin.Logger.LogWarning((object)"BackToLobby ignored - not in a run");
				return;
			}
			RunManager instance = RunManager.instance;
			if (!instance.restarting)
			{
				int num = (SemiFunc.IsLevelShop(instance.levelCurrent) ? 1 : (SemiFunc.RunIsLobby() ? 2 : 0));
				instance.ChangeLevel(true, SemiFunc.RunIsArena(), (ChangeLevelType)3);
				SemiFunc.StatSetSaveLevel(num);
				instance.loadLevel = num;
				StatsManager.instance.SaveFileSave();
				return;
			}
			if (!instance.restartingDone)
			{
				try
				{
					if (RetargetInFlightToLobby(instance))
					{
						return;
					}
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogWarning((object)("BackToLobby retarget failed (" + ex.GetType().Name + ") - queuing instead"));
				}
			}
			PendingLobbyReturn = true;
			Plugin.Logger.LogInfo((object)"BackToLobby queued - will run once the in-flight load completes");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool TrySyncLobbyDestinationRaw(RunManager rm)
		{
			if ((Object)(object)rm.levelCurrent == (Object)(object)rm.levelLobbyMenu)
			{
				return true;
			}
			if (!GameManager.Multiplayer())
			{
				rm.levelCurrent = rm.levelLobbyMenu;
				return true;
			}
			RunManagerPUN runManagerPUN = rm.runManagerPUN;
			if ((Object)(object)runManagerPUN == (Object)null || (Object)(object)runManagerPUN.photonView == (Object)null)
			{
				return false;
			}
			runManagerPUN.photonView.RPC("UpdateLevelRPC", (RpcTarget)4, new object[3]
			{
				((Object)rm.levelLobbyMenu).name,
				rm.levelsCompleted,
				false
			});
			rm.levelCurrent = rm.levelLobbyMenu;
			return true;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool RetargetInFlightToLobby(RunManager rm)
		{
			if (!TrySyncLobbyDestinationRaw(rm))
			{
				return false;
			}
			int saveLevel = rm.saveLevel;
			SemiFunc.StatSetSaveLevel(saveLevel);
			rm.loadLevel = saveLevel;
			StatsManager.instance.SaveFileSave();
			PendingLobbyReturn = true;
			Plugin.Logger.LogInfo((object)"BackToLobby: retargeted the in-flight load to the lobby menu");
			return true;
		}

		internal static void ForceLobbyReload()
		{
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				return;
			}
			try
			{
				ForceLobbyReloadRaw();
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogWarning((object)("ForceLobbyReload failed (" + ex.GetType().Name + ")"));
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ForceLobbyReloadRaw()
		{
			//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)
			RunManager instance = RunManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			bool flag = false;
			try
			{
				flag = TrySyncLobbyDestinationRaw(instance);
			}
			catch
			{
			}
			instance.waitToChangeScene = false;
			instance.lobbyJoin = false;
			instance.restarting = false;
			instance.restartingDone = false;
			instance.gameOver = false;
			instance.allPlayersDead = false;
			instance.allPlayersDeadCheckDisabled = true;
			try
			{
				StatsManager instance2 = StatsManager.instance;
				if (instance2 != null)
				{
					instance2.SaveFileSave();
				}
			}
			catch
			{
			}
			try
			{
				NetworkManager instance3 = NetworkManager.instance;
				if ((Object)(object)instance3 != (Object)null)
				{
					instance3.DestroyAll();
				}
			}
			catch
			{
			}
			PendingLobbyReturn = true;
			Scene activeScene = SceneManager.GetActiveScene();
			string text = ((((Scene)(ref activeScene)).name == "Reload") ? "Main" : "Reload");
			if (GameManager.Multiplayer() && PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient)
			{
				PhotonNetwork.AutomaticallySyncScene = true;
				PhotonNetwork.LoadLevel(text);
			}
			else
			{
				SceneManager.LoadSceneAsync(text);
			}
			Plugin.Logger.LogInfo((object)$"ForceLobbyReload: wedged transition pipeline restarted room-wide (forced scene: {text}, lobby synced: {flag})");
		}

		internal static void TickPendingLobbyReturn()
		{
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			if (!PendingLobbyReturn)
			{
				return;
			}
			if (!SemiFunc.IsMasterClientOrSingleplayer())
			{
				PendingLobbyReturn = false;
				return;
			}
			RunManager instance = RunManager.instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			if (SemiFunc.RunIsLobbyMenu() || SemiFunc.MenuLevel())
			{
				PendingLobbyReturn = false;
			}
			else if (!instance.restarting)
			{
				GameDirector instance2 = GameDirector.instance;
				if (!((Object)(object)instance2 == (Object)null) && (int)instance2.currentState == 2)
				{
					PendingLobbyReturn = false;
					Plugin.Logger.LogInfo((object)"BackToLobby: running queued lobby return");
					ReturnToLobby();
				}
			}
		}

		internal static void StartGame()
		{
			if (!SemiFunc.RunIsLobbyMenu())
			{
				Plugin.Logger.LogWarning((object)"StartGame ignored - host is not in the lobby menu");
				return;
			}
			if ((Object)(object)MenuPageLobby.instance != (Object)null && MenuPageLobby.instance.joiningPlayer)
			{
				Plugin.Logger.LogWarning((object)"StartGame ignored - a player is joining (native ButtonStart denies this)");
				return;
			}
			if (PhotonNetwork.CurrentRoom != null)
			{
				PhotonNetwork.CurrentRoom.IsOpen = false;
				PhotonNetwork.CurrentRoom.IsVisible = false;
			}
			SteamManager.instance.LockLobby();
			DataDirector.instance.RunsPlayedAdd();
			RunManager instance = RunManager.instance;
			if (instance.loadLevel == 1)
			{
				instance.ChangeLevel(true, false, (ChangeLevelType)5);
			}
			else if (instance.loadLevel == 2)
			{
				instance.ChangeLevel(true, false, (ChangeLevelType)0);
			}
			else
			{
				instance.ChangeLevel(true, false, (ChangeLevelType)1);
			}
		}

		internal static void Kick(PlayerAvatar? player, bool ban)
		{
			if ((Object)(object)player == (Object)null)
			{
				Plugin.Logger.LogWarning((object)"Kick requested for null player avatar - ignored");
			}
			else if (ban)
			{
				NetworkManager.instance.BanPlayer(player);
			}
			else
			{
				NetworkManager.instance.KickPlayer(player);
			}
		}

		internal static void KickByActorNumber(int actorNumber, bool ban)
		{
			//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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (actorNumber <= 0)
			{
				Plugin.Logger.LogWarning((object)string.Format("{0} by actor skipped - invalid actor number {1}", ban ? "Ban" : "Kick", actorNumber));
				return;
			}
			object[] array = new object[1] { actorNumber };
			RaiseEventOptions val = new RaiseEventOptions
			{
				Receivers = (ReceiverGroup)1
			};
			PhotonNetwork.RaiseEvent((byte)(ban ? 124 : 123), (object)array, val, SendOptions.SendReliable);
			try
			{
				Room currentRoom = PhotonNetwork.CurrentRoom;
				Player val2 = ((currentRoom != null) ? currentRoom.GetPlayer(actorNumber, false) : null);
				if (val2 != null && PhotonNetwork.IsMasterClient)
				{
					PhotonNetwork.CloseConnection(val2);
				}
			}
			catch
			{
			}
		}

		internal static PBanOutcome RecordPersistentBan(string? steamId, string targetName, string? senderName, string? senderSteamId)
		{
			if (string.IsNullOrEmpty(steamId) || !ulong.TryParse(steamId, out var result) || result == 0L)
			{
				Plugin.Logger.LogWarning((object)("Persistent ban record skipped - no usable Steam64 for " + targetName + " (" + (steamId ?? "null") + ")"));
				return PBanOutcome.Failed;
			}
			string reason = ((senderName == null) ? "SharePermissions: banned by host" : ("SharePermissions: banned via moderator " + senderName + " (" + senderSteamId + ")"));
			bool flag = BanEnforcerBridge.TryBan(result, reason, targetName);
			if (!flag)
			{
				Plugin.Logger.LogWarning((object)("Persistent ban record FAILED for " + targetName + " (" + steamId + ") - BanEnforcer unavailable or refused"));
			}
			if (!flag)
			{
				return PBanOutcome.Failed;
			}
			return PBanOutcome.Recorded;
		}
	}
	internal static class Hotkeys
	{
		internal static void Tick()
		{
			//IL_0015: 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)
			if (PrivateVoiceChannel.LocalActive && !TextInputFocused())
			{
				if (Input.GetKeyDown(ModConfig.PrivateMicMuteKey.Value))
				{
					PrivateVoiceLocalPrefs.ToggleMicMuted();
					Report(PrivateVoiceLocalPrefs.MicMuted ? "Private mic muted" : "Private mic on", PrivateVoiceLocalPrefs.MicMuted);
				}
				if (Input.GetKeyDown(ModConfig.PrivateDeafenKey.Value))
				{
					PrivateVoiceLocalPrefs.ToggleMuted();
					Report(PrivateVoiceLocalPrefs.Muted ? "Private sound muted" : "Private sound on", PrivateVoiceLocalPrefs.Muted);
				}
			}
		}

		private static void Report(string text, bool muted)
		{
			//IL_0018: 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 (!ModConfig.ShowPrivateChannelHud.Value)
			{
				NotificationCenter.EnqueueDirect(text, muted ? ModStyle.SevMute : ModStyle.SevInfo);
			}
		}

		private static bool TextInputFocused()
		{
			try
			{
				return TextInputFocusedRaw();
			}
			catch
			{
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool TextInputFocusedRaw()
		{
			if (REPOInputStringSystem.hasAnyFocus)
			{
				return true;
			}
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null)
			{
				return false;
			}
			GameObject currentSelectedGameObject = current.currentSelectedGameObject;
			if ((Object)(object)currentSelectedGameObject == (Object)null)
			{
				return false;
			}
			if (!((Object)(object)currentSelectedGameObject.GetComponent<TMP_InputField>() != (Object)null))
			{
				return (Object)(object)currentSelectedGameObject.GetComponent<InputField>() != (Object)null;
			}
			return true;
		}
	}
	internal enum FloodMode
	{
		Off,
		LogOnly,
		Kick
	}
	internal static class ModConfig
	{
		internal static ConfigEntry<FloodMode> Mode { get; private set; }

		internal static ConfigEntry<int> RpcFloodPerSecond { get; private set; }

		internal static ConfigEntry<int> AutoKickRpcPerSecond { get; private set; }

		internal static ConfigEntry<int> RpcMaxBytes { get; private set; }

		internal static ConfigEntry<string> GrantedModerators { get; private set; }

		internal static ConfigEntry<string> PromotedTokens { get; private set; }

		internal static ConfigEntry<string> MyModeratorTokens { get; private set; }

		internal static ConfigEntry<bool> GrantAdminMenu { get; private set; }

		internal static ConfigEntry<bool> ShowHeadMarkers { get; private set; }

		internal static ConfigEntry<bool> ShowModeratorNameColor { get; private set; }

		internal static ConfigEntry<string> NameColorHost { get; private set; }

		internal static ConfigEntry<string> NameColorModerator { get; private set; }

		internal static ConfigEntry<string> NameColorOverrides { get; private set; }

		internal static ConfigEntry<bool> ShowGhostRows { get; private set; }

		internal static ConfigEntry<bool> ShowTalkDots { get; private set; }

		internal static ConfigEntry<bool> PersistHistory { get; private set; }

		internal static ConfigEntry<bool> WriteForensicLog { get; private set; }

		internal static ConfigEntry<int> PersistedHistoryCount { get; private set; }

		internal static ConfigEntry<int> StartCountdownSeconds { get; private set; }

		internal static ConfigEntry<bool> ConfirmBackToLobby { get; private set; }

		internal static ConfigEntry<bool> ShowNotifications { get; private set; }

		internal static ConfigEntry<int> NotificationSeconds { get; private set; }

		internal static ConfigEntry<bool> ShowPrivateChannelHud { get; private set; }

		internal static ConfigEntry<HudCorner> PrivateChannelHudCorner { get; private set; }

		internal static ConfigEntry<KeyCode> PrivateMicMuteKey { get; private set; }

		internal static ConfigEntry<KeyCode> PrivateDeafenKey { get; private set; }

		internal static ConfigEntry<int> PrivateChannelVolume { get; private set; }

		internal static void Init(ConfigFile config)
		{
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Expected O, but got Unknown
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Expected O, but got Unknown
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Expected O, but got Unknown
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Expected O, but got Unknown
			//IL_02e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Expected O, but got Unknown
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0394: Expected O, but got Unknown
			GrantedModerators = config.Bind<string>("Moderators", "GrantedModerators", "", "Deprecated and unused as of the token-based promotion model; kept only so older config files load without error. Runtime moderator grants are now issued as capability tokens (see PromotedTokens). Safe to delete.");
			PromotedTokens = config.Bind<string>("Moderators", "PromotedTokens", "", "Host-issued moderator capability tokens (comma-separated) this host has granted and not revoked. Entries are either a bare token or token:steamId:base64Name (the holder recorded at promote time, shown on the Tokens tab). Each promoted moderator holds a matching token and re-authorizes with it on reconnect. Managed by the in-game Members and Tokens tabs; removing an entry revokes that promotion.");
			MyModeratorTokens = config.Bind<string>("Moderators", "MyModeratorTokens", "", "Moderator tokens THIS client holds for hosts that promoted you (comma-separated). Entries are hostSteamId:token, optionally followed by :base64HostName:base64Lobby recorded when the token arrived so the Access tab can name the host from any lobby. Presented automatically on join so you regain moderator status without being re-promoted. Managed automatically. Older mod versions drop labeled entries on their next save - after a downgrade, ask to be re-promoted.");
			GrantAdminMenu = config.Bind<bool>("Moderators", "GrantAdminMenu", true, "Let your moderators open the R.E.P.O. Admin Menu while you are hosting. Requires the Admin Menu mod installed on BOTH machines - it is a local menu, so there is nothing to unlock on a moderator who does not have it. Host-authoritative: turning this off re-locks every moderator's menu, and the host still ignores any settings they try to push. Has no effect when you are not the host.");
			ShowHeadMarkers = config.Bind<bool>("UI", "ShowHeadMarkers", true, "Show the in-world role markers (crown/gem/diamond) above player heads in the lobby and truck.");
			ShowModeratorNameColor = config.Bind<bool>("UI", "ShowModeratorNameColor", true, "Tint host and moderator names with the host's chosen name colors - in the lobby player list, on the floating name above their head in-game, and on the escape menu's per-player volume rows. Your own display preference: turning it off shows stock names to you and nobody else. The colors themselves are set by the host (see the NameColors section).");
			NameColorHost = config.Bind<string>("NameColors", "NameColorHost", "ffd24a", "Color for the HOST's nickname, as 6 hex digits (RRGGBB, no '#'). Applies only when you are the host: your choice is sent to everyone running the mod. Managed by the Mod panel's Settings tab; safe to edit by hand.");
			NameColorModerator = config.Bind<string>("NameColors", "NameColorModerator", "66b2ff", "Color for MODERATOR nicknames, as 6 hex digits (RRGGBB, no '#'). Applies only when you are the host, and is sent to everyone running the mod. Managed by the Mod panel's Settings tab; safe to edit by hand.");
			NameColorOverrides = config.Bind<string>("NameColors", "NameColorOverrides", "", "Per-player nickname colors, as steamid:rrggbb pairs separated by commas. Overrides the two role colors above for those players, whatever their role. Managed by the Members panel; safe to edit by hand.");
			ShowGhostRows = config.Bind<bool>("UI", "ShowGhostRows", true, "Show ghost rows in the lobby player list for connected players that have no avatar yet, so they can be moderated too. Members whose nickname has no visible characters are never shown. On by default since 2.4.0 - the lobby list is now the one place a ghost can be kicked.");
			ShowTalkDots = config.Bind<bool>("UI", "ShowTalkDots", true, "Show the talk dot next to players in the Members panel while they are speaking.");
			PersistHistory = config.Bind<bool>("History", "PersistHistory", true, "Keep moderation History across sessions in a local file (sharepermissions-history.jsonl next to this config). Events you record and events synced to you as a moderator both persist; turning this off stops writing to that file and hides past sessions. The separate forensic sharepermissions.log has its own setting.");
			WriteForensicLog = config.Bind<bool>("History", "WriteForensicLog", true, "Append every moderation event this client records to sharepermissions.log next to this config. A plain-text forensic trail that survives 'Clear history' and is never shown in-game. Events synced to you as a moderator are never written here.");
			PersistedHistoryCount = config.Bind<int>("History", "PersistedHistoryCount", 200, new ConfigDescription("How many past events the History page loads from the persistent file", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 500), Array.Empty<object>()));
			Mode = config.Bind<FloodMode>("FloodProtection", "Mode", FloodMode.Kick, "RPC-flood handling: Off = disabled; LogOnly = measure and log peaks but never kick; Kick = drop floods locally and kick flooders (host kicks directly; moderators request the host). Dropping starts at RpcFloodPerSecond; kicking needs the higher AutoKickRpcPerSecond. Moderators' own RPCs are never flood-checked.");
			RpcFloodPerSecond = config.Bind<int>("FloodProtection", "RpcFloodPerSecond", 50, new ConfigDescription("Per-player incoming RPC/second above which packets are dropped locally (survivability). This alone never kicks anyone - see AutoKickRpcPerSecond.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10000), Array.Empty<object>()));
			AutoKickRpcPerSecond = config.Bind<int>("FloodProtection", "AutoKickRpcPerSecond", 350, new ConfigDescription("Per-player incoming RPC/second required before a flooder is actually kicked (Kick mode). Deliberately well above RpcFloodPerSecond so a transient burst - e.g. the RPC storm every client emits when someone joins the lobby - drops packets but never auto-kicks an innocent player. The 350 floor is a hard minimum, not just a UI limit: a lower value here is raised back to 350 on load, so no config can arm the auto-kick in join-storm territory. Clamped up to RpcFloodPerSecond if set lower.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(350, 100000), Array.Empty<object>()));
			RpcMaxBytes = config.Bind<int>("FloodProtection", "RpcMaxBytes", 16384, new ConfigDescription("Maximum size in bytes of a single incoming RPC before it is treated as a flood", (AcceptableValueBase)(object)new AcceptableValueRange<int>(512, 10000000), Array.Empty<object>()));
			StartCountdownSeconds = config.Bind<int>("Lobby", "StartCountdownSeconds", 5, new ConfigDescription("Seconds to count down before a run actually starts. Everyone in the lobby sees the countdown, and the host and moderators can cancel it before it fires. Set to 0 to start instantly with no countdown.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 60), Array.Empty<object>()));
			ConfirmBackToLobby = config.Bind<bool>("Lobby", "ConfirmBackToLobby", true, "Ask for a Yes/No confirmation before the 'Back to lobby' button returns everyone to the lobby.");
			ShowNotifications = config.Bind<bool>("Notifications", "ShowNotifications", true, "Show short on-screen notifications: moderation events (host and moderators - a live mirror of the History feed) and your own promote/demote notices. Local display preference; History records everything regardless.");
			NotificationSeconds = config.Bind<int>("Notifications", "NotificationSeconds", 4, new ConfigDescription("How long each notification stays on screen, in seconds", (AcceptableValueBase)(object)new AcceptableValueRange<int>(2, 10), Array.Empty<object>()));
			ShowPrivateChannelHud = config.Bind<bool>("Notifications", "ShowPrivateChannelHud", true, "While the private host/moderator voice channel is on, show an always-visible on-screen list of its members and who is talking. Local display preference; channel members only.");
			PrivateChannelHudCorner = config.Bind<HudCorner>("Notifications", "PrivateChannelHudCorner", HudCorner.TopRight, "Which screen corner the private-channel member list sits in: TopLeft, TopRight, BottomLeft or BottomRight. BottomLeft overlaps the notification toasts.");
			PrivateMicMuteKey = config.Bind<KeyCode>("Hotkeys", "PrivateMicMuteKey", (KeyCode)285, "Key that mutes and unmutes YOUR MICROPHONE in the private host/moderator voice channel. Local and session-only: it silences only your private stream and is never sent to anyone. Ignored while you are not a member of the channel, and while a text field has focus. Set to None to unbind.");
			PrivateDeafenKey = config.Bind<KeyCode>("Hotkeys", "PrivateDeafenKey", (KeyCode)0, "Key that mutes and unmutes what you HEAR from the private host/moderator voice channel (the 'Sound' control on the Mod panel's + tab). Unbound by default. Local and session-only, with the same gates as PrivateMicMuteKey.");
			PrivateChannelVolume = config.Bind<int>("Voice", "PrivateChannelVolume", 100, new ConfigDescription("How loud the private host/moderator voice channel plays for YOU, in percent. 100 leaves it exactly as the game's own Master Volume and Proximity Voice settings deliver it, below 100 quietens it, and above 100 amplifies it past the level a plain AudioSource can reach. Local to your machine, applied only to the private channel - it never touches ordinary voice chat and is never sent to anyone. Also on the Mod panel's + tab.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 300), Array.Empty<object>()));
		}
	}
	internal sealed class ModHeartbeat : MonoBehaviour
	{
		private static ModHeartbeat? instance;

		internal static void Init()
		{
			//IL_0013: 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_0021: Expected O, but got Unknown
			if (!((Object)(object)instance != (Object)null))
			{
				GameObject val = new GameObject("SharePermissionsHeartbeat")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)(object)val);
				instance = val.AddComponent<ModHeartbeat>();
			}
		}

		private void Update()
		{
			try
			{
				GameActions.TickPendingLobbyReturn();
			}
			catch
			{
			}
			try
			{
				JoinAnnouncer.Tick();
			}
			catch
			{
			}
			try
			{
				Hotkeys.Tick();
			}
			catch
			{
			}
			try
			{
				PrivateVoiceDriver.Tick();
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Private voice tick failed - tearing down: {arg}");
				try
				{
					PrivateVoiceDriver.TearDown("tick failure");
				}
				catch
				{
				}
				PrivateVoiceChannel.Clear();
			}
		}
	}
	internal static class NotificationKinds
	{
		internal const string Kick = "kick";

		internal const string Ban = "ban";

		internal const string GhostKick = "ghostkick";

		internal const string GhostBan = "ghostban";

		internal const string Flood = "flood";

		internal const string Grant = "grant";

		internal const string Revoke = "revoke";

		internal const string Start = "start";

		internal const string Lobby = "lobby";

		internal const string Info = "info";

		internal const string None = "none";
	}
	[BepInPlugin("RED.SharePermissions", "SharePermissions", "2.4.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		private Harmony? harmony;

		internal static ManualLogSource Logger { get; private set; }

		private void Awake()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			ModConfig.Init(((BaseUnityPlugin)this).Config);
			((BaseUnityPlugin)this).Config.SettingChanged += OnConfigSettingChanged;
			NameColors.ApplyLocalConfig();
			AuditStore.Init();
			harmony = new Harmony("RED.SharePermissions");
			harmony.PatchAll();
			AdminMenuGatePatch.Init(harmony);
			PlayerAvatarIndicatorPatch.Init();
			ModHeartbeat.Init();
			NotificationCenter.Init();
			NotificationOverlay.Init();
			PrivateChannelHud.Init();
			ModUi.Init();
			StartCountdownDriver.Init();
			PrivateVoiceClient.Init();
			Logger.LogInfo((object)"RED.SharePermissions v2.4.2 has loaded!");
		}

		private static void OnConfigSettingChanged(object sender, SettingChangedEventArgs args)
		{
			ConfigEntryBase changedSetting = args.ChangedSetting;
			if ((object)changedSetting == ModConfig.PromotedTokens)
			{
				PromotedTokenStore.InvalidateCache();
			}
			else if ((object)changedSetting == ModConfig.MyModeratorTokens)
			{
				ClientTokenStore.InvalidateCache();
			}
			else if (((object)changedSetting == ModConfig.NameColorHost || (object)changedSetting == ModConfig.NameColorModerator || (object)changedSetting == ModConfig.NameColorOverrides) && !NameColors.IsApplyingConfig)
			{
				NameColors.ApplyLocalConfig();
				NameColorSync.Broadcast();
			}
		}
	}
	internal static class PluginInfo
	{
		internal const string Guid = "RED.SharePermissions";

		internal const string Name = "SharePermissions";

		internal const string Version = "2.4.2";
	}
	internal static class SessionState
	{
		internal static void Reset(string reason)
		{
			Plugin.Logger.LogInfo((object)("Resetting session state (" + reason + ")"));
			Moderators.Instance.Clear();
			AuthorizedActors.Clear();
			ModUsers.Instance.Clear();
			HostCapabilities.Clear();
			NameColors.Clear();
			PlayerRegistry.Instance.Clear();
			RpcFloodMonitor.Instance.Clear();
			ModHelloCommand.ResetRateLimit();
			FloodKeepAlive.Reset();
			AuditLog.Clear();
			AuditSyncCommand.ResetLimits();
			AnnounceCommand.ResetLimits();
			NotesSync.ResetSession();
			NotesSyncCommand.ResetLimits();
			NotesUploadCommand.ResetLimits();
			NoteDeleteCommand.ResetLimits();
			NoteTombstoneCommand.ResetLimits();
			VoiceVolumes.Clear();
			PrivateVoiceChannel.Clear();
			try
			{
				PrivateVoiceDriver.TearDown("session reset");
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"Private voice teardown failed during session reset: {arg}");
			}
			PrivateVoiceSync.Reset();
			ModerationActions.ClearSessionCache();
			GameActions.PendingLobbyReturn = false;
			JoinAnnouncer.Clear();
			NotificationCenter.ResetSession();
			NotesJoinToast.Reset();
		}
	}
}
namespace SharePermissions.Api
{
	public static class LoadingWidgetBridge
	{
		public static bool LocalCanModerate => ModerationActions.LocalCanModerate;

		public static bool ShowLoadingPanel => true;

		public static float VolumeMax => 2f;

		public static bool PendingLobbyReturn => GameActions.PendingLobbyReturn;

		public static bool IsMasterOrSingleplayer => SemiFunc.IsMasterClientOrSingleplayer();

		public static int RoleTier(Player? player)
		{
			return (int)RoleResolver.ResolveByPlayer(player);
		}

		public static float VoiceAmplitude(int actorNumber)
		{
			return VoiceChatPatch.AmplitudeFor(actorNumber);
		}

		public static float VolumeFactor(int actorNumber)
		{
			return VoiceVolumes.FactorFor(actorNumber);
		}

		public static void SetVolume(int actorNumber, float factor)
		{
			VoiceVolumes.Set(actorNumber, factor);
		}

		public static string SanitizeName(string? name, string? fallback = "Unknown")
		{
			return MenuUiHelpers.SanitizePlayerName(name, fallback);
		}

		public static bool CanKick(PlayerAvatar target)
		{
			return ModerationActions.ShouldShowKickFor(target);
		}

		public static bool CanKickActor(Player target)
		{
			return ModerationActions.ShouldShowKickForActor(target);
		}

		public static void Kick(PlayerAvatar target, bool ban)
		{
			ModerationActions.KickPlayer(target, ban);
		}

		public static void KickGhost(Player ghost, bool ban)
		{
			ModerationActions.KickGhost(ghost, ban);
		}

		public static void BackToLobby()
		{
			ModerationActions.BackToLobby();
		}

		public static void ForceLobbyReload()
		{
			GameActions.ForceLobbyReload();
		}
	}
}