using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using MenuLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using Steamworks;
using Steamworks.Data;
using UnityEngine;
using UnityEngine.Networking;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace RepoMods.PhotonBanEnforcer
{
	public static class RepoBanPatcher
	{
		public static void Apply(Harmony harmony)
		{
			harmony.PatchAll(typeof(RepoBanPatcher).Assembly);
		}
	}
	public class RepoBanManager : MonoBehaviourPunCallbacks
	{
		[Serializable]
		private class SaveModel
		{
			public List<string> keys = new List<string>();
		}

		private class PlayerInfo
		{
			public string NickName;

			public string SteamId;

			public int ActorNumber;

			public DateTime LastSeen;

			public bool HasSid => !string.IsNullOrEmpty(SteamId);
		}

		[CompilerGenerated]
		private sealed class <DelayedCacheCleanup>d__38 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public int actorNumber;

			public RepoBanManager <>4__this;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(30f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>4__this._playerCache.Remove(actorNumber);
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <DelayedCheck>d__36 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public Player player;

			public RepoBanManager <>4__this;

			private string <sidText>5__1;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<sidText>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (player != null && PhotonNetwork.PlayerList.Contains(player))
					{
						<sidText>5__1 = <>4__this.ResolveSteam64For(player);
						if (<>4__this.IsSteam64Banned(<sidText>5__1))
						{
							Debug.Log((object)("[RepoBan] Delayed detection of banned player: " + player.NickName));
							<>4__this.EnforceKick(player, <sidText>5__1);
						}
						<sidText>5__1 = null;
					}
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <DelayedScan>d__34 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RepoBanManager <>4__this;

			private Player[] <>s__1;

			private int <>s__2;

			private Player <p>5__3;

			private string <sidText>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>s__1 = null;
				<p>5__3 = null;
				<sidText>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>s__1 = PhotonNetwork.PlayerList;
					for (<>s__2 = 0; <>s__2 < <>s__1.Length; <>s__2++)
					{
						<p>5__3 = <>s__1[<>s__2];
						<sidText>5__4 = <>4__this.ResolveSteam64For(<p>5__3);
						if (<>4__this.IsSteam64Banned(<sidText>5__4))
						{
							<>4__this.EnforceKick(<p>5__3, <sidText>5__4);
						}
						<sidText>5__4 = null;
						<p>5__3 = null;
					}
					<>s__1 = null;
					return false;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <UpdatePlayerInfoRoutine>d__17 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RepoBanManager <>4__this;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0029: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					if (PhotonNetwork.InRoom)
					{
						<>4__this.UpdatePlayerCache();
						<>4__this.EnforceExistingBans();
					}
					<>4__this.RefreshSteamLobbyMap();
					break;
				}
				<>2__current = (object)new WaitForSeconds(2f);
				<>1__state = 1;
				return true;
			}

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

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

		public static bool VerboseLogs;

		public static bool LogLocalIds;

		private readonly HashSet<string> _localSteamKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

		private readonly Dictionary<int, PlayerInfo> _playerCache = new Dictionary<int, PlayerInfo>();

		private readonly Dictionary<ulong, string> _steamLobbyMembers = new Dictionary<ulong, string>();

		private readonly Dictionary<string, List<ulong>> _nameToSteamIds = new Dictionary<string, List<ulong>>(StringComparer.Ordinal);

		private static string _savePath;

		public static RepoBanManager Instance { get; private set; }

		private static string SavePath
		{
			get
			{
				if (!string.IsNullOrEmpty(_savePath))
				{
					return _savePath;
				}
				try
				{
					_savePath = Path.Combine(Paths.ConfigPath, "RepoBanList.json");
				}
				catch
				{
					_savePath = Path.Combine(Application.persistentDataPath, "RepoBanList.json");
				}
				return _savePath;
			}
		}

		public static void EnsureExists()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)Instance))
			{
				GameObject val = new GameObject("RepoBanManager");
				Object.DontDestroyOnLoad((Object)(object)val);
				Instance = val.AddComponent<RepoBanManager>();
				Instance.LoadLocal();
				Debug.Log((object)"[RepoBan] Manager created (Steam-only).");
			}
		}

		private void Start()
		{
			((MonoBehaviour)this).StartCoroutine(UpdatePlayerInfoRoutine());
			RefreshSteamLobbyMap();
		}

		[IteratorStateMachine(typeof(<UpdatePlayerInfoRoutine>d__17))]
		private IEnumerator UpdatePlayerInfoRoutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdatePlayerInfoRoutine>d__17(0)
			{
				<>4__this = this
			};
		}

		internal void RefreshSteamLobbyMap()
		{
			//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_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0072: 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)
			try
			{
				if ((Object)(object)SteamManager.instance == (Object)null)
				{
					return;
				}
				Lobby currentLobby = SteamManager.instance.currentLobby;
				SteamId id = ((Lobby)(ref currentLobby)).Id;
				if (!((SteamId)(ref id)).IsValid)
				{
					return;
				}
				_steamLobbyMembers.Clear();
				_nameToSteamIds.Clear();
				foreach (Friend member in ((Lobby)(ref currentLobby)).Members)
				{
					Friend current = member;
					ulong value = current.Id.Value;
					string text = ((Friend)(ref current)).Name ?? string.Empty;
					_steamLobbyMembers[value] = text;
					if (!string.IsNullOrEmpty(text))
					{
						if (!_nameToSteamIds.TryGetValue(text, out List<ulong> value2))
						{
							value2 = new List<ulong>();
							_nameToSteamIds[text] = value2;
						}
						if (!value2.Contains(value))
						{
							value2.Add(value);
						}
					}
				}
			}
			catch
			{
			}
		}

		public string ResolveSteam64For(Player p)
		{
			if (p == null)
			{
				return null;
			}
			PlayerInfo orCreatePlayerInfo = GetOrCreatePlayerInfo(p);
			if (!string.IsNullOrEmpty(orCreatePlayerInfo.SteamId))
			{
				return orCreatePlayerInfo.SteamId;
			}
			string text = ExtractSteam64FromCustomProps(p);
			if (!string.IsNullOrEmpty(text))
			{
				orCreatePlayerInfo.SteamId = text;
				return text;
			}
			if (!string.IsNullOrEmpty(p.NickName) && _nameToSteamIds.TryGetValue(p.NickName, out List<ulong> value) && value.Count > 0)
			{
				orCreatePlayerInfo.SteamId = value[0].ToString();
			}
			return orCreatePlayerInfo.SteamId;
		}

		private string ExtractSteam64FromCustomProps(Player player)
		{
			if (((player != null) ? player.CustomProperties : null) == null)
			{
				return null;
			}
			string[] array = new string[5] { "steamId", "steamID", "steamid", "SteamId", "STEAMID" };
			string[] array2 = array;
			foreach (string text in array2)
			{
				if (!((Dictionary<object, object>)(object)player.CustomProperties).TryGetValue((object)text, out object value))
				{
					continue;
				}
				string text2 = value?.ToString();
				if (!string.IsNullOrEmpty(text2) && text2 != "0")
				{
					if (VerboseLogs && (!player.IsLocal || LogLocalIds))
					{
						Debug.Log((object)("[RepoBan] Found Steam ID for " + player.NickName + ": " + text2 + " (" + text + ")"));
					}
					return text2;
				}
			}
			if (!string.IsNullOrEmpty(player.UserId) && player.UserId.All(char.IsDigit) && player.UserId.Length >= 10)
			{
				return player.UserId;
			}
			return null;
		}

		private void UpdatePlayerCache()
		{
			Player[] playerList = PhotonNetwork.PlayerList;
			foreach (Player val in playerList)
			{
				if (val != null)
				{
					PlayerInfo orCreatePlayerInfo = GetOrCreatePlayerInfo(val);
					bool hasSid = orCreatePlayerInfo.HasSid;
					orCreatePlayerInfo.NickName = val.NickName;
					orCreatePlayerInfo.ActorNumber = val.ActorNumber;
					orCreatePlayerInfo.LastSeen = DateTime.Now;
					orCreatePlayerInfo.SteamId = ResolveSteam64For(val);
					if (!hasSid && orCreatePlayerInfo.HasSid && IsSteam64Banned(orCreatePlayerInfo.SteamId))
					{
						Debug.Log((object)("[RepoBan] Newly identified banned player " + orCreatePlayerInfo.NickName + " — enforcing kick"));
						EnforceKick(val, orCreatePlayerInfo.SteamId);
					}
				}
			}
		}

		private PlayerInfo GetOrCreatePlayerInfo(Player player)
		{
			if (!_playerCache.TryGetValue(player.ActorNumber, out PlayerInfo value))
			{
				value = new PlayerInfo();
				_playerCache[player.ActorNumber] = value;
			}
			return value;
		}

		private void EnforceExistingBans()
		{
			Player[] playerList = PhotonNetwork.PlayerList;
			foreach (Player val in playerList)
			{
				if (val != null && !val.IsLocal)
				{
					string s = ResolveSteam64For(val);
					if (ulong.TryParse(s, out var result) && IsSteamIdBanned(result))
					{
						PlayerInfo orCreatePlayerInfo = GetOrCreatePlayerInfo(val);
						Debug.Log((object)$"[RepoBan] Enforcing ban on {orCreatePlayerInfo.NickName} ({result})");
						EnforceKick(val, result.ToString());
					}
				}
			}
		}

		public static void BanPlayer(Player p)
		{
			if (p != null && !((Object)(object)Instance == (Object)null))
			{
				string s = Instance.ResolveSteam64For(p);
				if (!ulong.TryParse(s, out var result))
				{
					Debug.LogWarning((object)("[RepoBan] Could not resolve Steam64 for " + p.NickName + ". Use the Steam panel/manual field."));
				}
				else
				{
					BanBySteamId(result, p.NickName);
				}
			}
		}

		public static void BanBySteamId(ulong steamId, string displayName = null)
		{
			//IL_0057: 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_0072: 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_007b: 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)
			if (steamId == 0L || (Object)(object)Instance == (Object)null)
			{
				return;
			}
			Instance._localSteamKeys.Add(PrefixSteam(steamId.ToString()));
			Instance.SaveLocal();
			try
			{
				Lobby? val = SteamManager.instance?.currentLobby;
				if (val.HasValue)
				{
					Lobby value = val.Value;
					SteamId id = ((Lobby)(ref value)).Id;
					if (((SteamId)(ref id)).IsValid && SteamLobbyKickUtil.TryKick(val.Value, steamId))
					{
						Debug.Log((object)$"[RepoBan] Steam gate blocked {steamId} via manual ban");
					}
				}
			}
			catch
			{
			}
			Player[] playerList = PhotonNetwork.PlayerList;
			foreach (Player val2 in playerList)
			{
				string text = Instance.ResolveSteam64For(val2);
				if (text == steamId.ToString())
				{
					Instance.EnforceKick(val2, text);
				}
				else if (!string.IsNullOrEmpty(displayName) && string.Equals(val2.NickName, displayName, StringComparison.Ordinal))
				{
					Instance.EnforceKick(val2, steamId.ToString());
				}
			}
		}

		public static void RemoveSteamKey(string key)
		{
			if (!((Object)(object)Instance == (Object)null) && !string.IsNullOrEmpty(key) && Instance._localSteamKeys.Remove(key))
			{
				Instance.SaveLocal();
			}
		}

		public static void ClearAllLocalBans()
		{
			if (!((Object)(object)Instance == (Object)null))
			{
				Instance._localSteamKeys.Clear();
				Instance.SaveLocal();
			}
		}

		public static List<string> LocalSteamKeysSnapshot()
		{
			List<string> source = new List<string>(Instance?._localSteamKeys ?? new HashSet<string>());
			source = source.Where((string k) => k.StartsWith("steam:", StringComparison.OrdinalIgnoreCase)).ToList();
			source.Sort(StringComparer.OrdinalIgnoreCase);
			return source;
		}

		public static Dictionary<ulong, string> SteamLobbySnapshot()
		{
			Dictionary<ulong, string> dictionary = new Dictionary<ulong, string>();
			if ((Object)(object)Instance == (Object)null)
			{
				return dictionary;
			}
			foreach (KeyValuePair<ulong, string> steamLobbyMember in Instance._steamLobbyMembers)
			{
				dictionary[steamLobbyMember.Key] = steamLobbyMember.Value;
			}
			return dictionary;
		}

		private static string PrefixSteam(string id)
		{
			return "steam:" + id;
		}

		public static bool IsSteamIdBanned(ulong steamId)
		{
			if ((Object)(object)Instance == (Object)null || steamId == 0)
			{
				return false;
			}
			return Instance._localSteamKeys.Contains(PrefixSteam(steamId.ToString()));
		}

		private bool IsSteam64Banned(string sidText)
		{
			if (ulong.TryParse(sidText, out var result))
			{
				return IsSteamIdBanned(result);
			}
			return false;
		}

		public override void OnJoinedRoom()
		{
			((MonoBehaviourPunCallbacks)this).OnJoinedRoom();
			_playerCache.Clear();
			RepoBanEnforcerPlugin.ResetManualCloseFlag();
			((MonoBehaviour)this).StartCoroutine(DelayedScan());
		}

		[IteratorStateMachine(typeof(<DelayedScan>d__34))]
		private IEnumerator DelayedScan()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedScan>d__34(0)
			{
				<>4__this = this
			};
		}

		public override void OnPlayerEnteredRoom(Player newPlayer)
		{
			((MonoBehaviourPunCallbacks)this).OnPlayerEnteredRoom(newPlayer);
			if (VerboseLogs)
			{
				Debug.Log((object)$"[RepoBan] Player entered: {newPlayer.NickName} (Actor: {newPlayer.ActorNumber})");
			}
			string text = ResolveSteam64For(newPlayer);
			if (IsSteam64Banned(text))
			{
				Debug.Log((object)("[RepoBan] Immediately detected banned player: " + newPlayer.NickName));
				EnforceKick(newPlayer, text);
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(DelayedCheck(newPlayer));
			}
		}

		[IteratorStateMachine(typeof(<DelayedCheck>d__36))]
		private IEnumerator DelayedCheck(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedCheck>d__36(0)
			{
				<>4__this = this,
				player = player
			};
		}

		public override void OnPlayerLeftRoom(Player otherPlayer)
		{
			((MonoBehaviourPunCallbacks)this).OnPlayerLeftRoom(otherPlayer);
			((MonoBehaviour)this).StartCoroutine(DelayedCacheCleanup(otherPlayer.ActorNumber));
		}

		[IteratorStateMachine(typeof(<DelayedCacheCleanup>d__38))]
		private IEnumerator DelayedCacheCleanup(int actorNumber)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedCacheCleanup>d__38(0)
			{
				<>4__this = this,
				actorNumber = actorNumber
			};
		}

		private void EnforceKick(Player target, string id)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			if (target != null)
			{
				Debug.Log((object)$"[RepoBan] Enforcing kick on {target.NickName} (Steam64: {id}, Actor: {target.ActorNumber})");
				if (PhotonNetwork.IsMasterClient)
				{
					PhotonNetwork.RemoveRPCs(target);
					PhotonNetwork.DestroyPlayerObjects(target);
					RaiseEventOptions val = new RaiseEventOptions();
					val.TargetActors = new int[1] { target.ActorNumber };
					PhotonNetwork.RaiseEvent((byte)199, (object)null, val, SendOptions.SendReliable);
					bool flag = PhotonNetwork.CloseConnection(target);
					Debug.Log((object)$"[RepoBan] Master closed connection for {target.ActorNumber}/{id}: {flag}");
				}
			}
		}

		private void SaveLocal()
		{
			try
			{
				SaveModel saveModel = new SaveModel
				{
					keys = _localSteamKeys.ToList()
				};
				string contents = JsonUtility.ToJson((object)saveModel, true);
				Directory.CreateDirectory(Path.GetDirectoryName(SavePath));
				File.WriteAllText(SavePath, contents);
				Debug.Log((object)$"[RepoBan] Saved {saveModel.keys.Count} local steam bans to {SavePath}");
			}
			catch (Exception arg)
			{
				Debug.LogWarning((object)$"[RepoBan] SaveLocal failed: {arg}");
			}
		}

		private void LoadLocal()
		{
			try
			{
				_localSteamKeys.Clear();
				if (!File.Exists(SavePath))
				{
					return;
				}
				string text = File.ReadAllText(SavePath);
				SaveModel saveModel = JsonUtility.FromJson<SaveModel>(text);
				if (saveModel?.keys != null)
				{
					foreach (string key in saveModel.keys)
					{
						if (!string.IsNullOrEmpty(key) && key.StartsWith("steam:", StringComparison.OrdinalIgnoreCase))
						{
							_localSteamKeys.Add(key);
						}
					}
				}
				Debug.Log((object)$"[RepoBan] Loaded {_localSteamKeys.Count} local steam bans from {SavePath}");
			}
			catch (Exception arg)
			{
				Debug.LogWarning((object)$"[RepoBan] LoadLocal failed: {arg}");
			}
		}

		public static void DumpDebugInfo()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Debug.Log((object)"[RepoBan] Manager not initialized");
				return;
			}
			Debug.Log((object)"[RepoBan] === DEBUG INFO ===");
			Debug.Log((object)$"[RepoBan] Local steam keys: {Instance._localSteamKeys.Count}");
			foreach (string localSteamKey in Instance._localSteamKeys)
			{
				Debug.Log((object)("[RepoBan]   - " + localSteamKey));
			}
			Debug.Log((object)$"[RepoBan] Steam lobby members: {Instance._steamLobbyMembers.Count}");
			foreach (KeyValuePair<ulong, string> steamLobbyMember in Instance._steamLobbyMembers)
			{
				Debug.Log((object)$"[RepoBan]   - {steamLobbyMember.Value} ({steamLobbyMember.Key})");
			}
			Debug.Log((object)$"[RepoBan] Cached players: {Instance._playerCache.Count}");
			foreach (KeyValuePair<int, PlayerInfo> item in Instance._playerCache)
			{
				PlayerInfo value = item.Value;
				Debug.Log((object)$"[RepoBan]   Actor{item.Key}: {value.NickName} | Steam64: '{value.SteamId}'");
			}
			Debug.Log((object)$"[RepoBan] Current Photon players: {PhotonNetwork.PlayerList.Length}");
			Player[] playerList = PhotonNetwork.PlayerList;
			foreach (Player val in playerList)
			{
				string text = Instance.ResolveSteam64For(val) ?? "Unknown";
				bool flag = Instance.IsSteam64Banned(text);
				Debug.Log((object)$"[RepoBan]   {val.NickName} | Steam64: '{text}' | Banned: {flag}");
			}
		}
	}
	[HarmonyPatch]
	public static class Patch_NetworkManager_BanPlayer
	{
		private static MethodBase TargetMethod()
		{
			Type type = AccessTools.TypeByName("NetworkManager");
			return (type != null) ? AccessTools.Method(type, "BanPlayer", (Type[])null, (Type[])null) : null;
		}

		private static void Postfix(object __instance, PlayerAvatar _playerAvatar)
		{
			try
			{
				if (!((Object)(object)_playerAvatar?.photonView == (Object)null))
				{
					int ownerActorNr = _playerAvatar.photonView.OwnerActorNr;
					Room currentRoom = PhotonNetwork.CurrentRoom;
					Player val = ((currentRoom != null) ? currentRoom.GetPlayer(ownerActorNr, false) : null);
					if (val == null)
					{
						Debug.LogWarning((object)$"[RepoBan] Could not resolve Player for actor {ownerActorNr}");
						return;
					}
					Debug.Log((object)("[RepoBan] NetworkManager.BanPlayer called for " + val.NickName + " (steam-only)"));
					RepoBanManager.BanPlayer(val);
				}
			}
			catch (Exception arg)
			{
				Debug.LogWarning((object)$"[RepoBan] BanPlayer postfix failed: {arg}");
			}
		}
	}
	internal static class SteamLobbyKickUtil
	{
		private static bool _loggedMissing;

		public static bool TryKick(Lobby lobby, ulong steamIdValue)
		{
			//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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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)
			try
			{
				Type typeFromHandle = typeof(SteamMatchmaking);
				SteamId id = ((Lobby)(ref lobby)).Id;
				SteamId val = SteamId.op_Implicit(steamIdValue);
				string[] array = new string[3] { "KickLobbyMember", "KickMember", "KickFromLobby" };
				string[] array2 = array;
				foreach (string name in array2)
				{
					MethodInfo method = typeFromHandle.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, new Type[2]
					{
						typeof(SteamId),
						typeof(SteamId)
					}, null);
					if (method != null)
					{
						method.Invoke(null, new object[2] { id, val });
						return true;
					}
				}
				if (!_loggedMissing)
				{
					_loggedMissing = true;
					Debug.LogWarning((object)"[RepoBan] Steam kick API not found in this Steamworks build. Will fall back to Photon kick if needed.");
				}
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[RepoBan] SteamLobbyKickUtil.TryKick error: " + ex.Message));
			}
			return false;
		}
	}
	internal static class SteamLobbyGate
	{
		private static bool _registered;

		public static void EnsureRegistered()
		{
			if (_registered)
			{
				return;
			}
			_registered = true;
			try
			{
				SteamMatchmaking.OnLobbyMemberJoined += OnLobbyMemberJoined;
				SteamMatchmaking.OnLobbyMemberLeave += OnLobbyMemberLeft;
				Debug.Log((object)"[RepoBan] SteamLobbyGate registered");
			}
			catch (Exception ex)
			{
				Debug.LogWarning((object)("[RepoBan] SteamLobbyGate registration failed: " + ex.Message));
				_registered = false;
			}
		}

		private static void OnLobbyMemberJoined(Lobby lobby, Friend friend)
		{
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: 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_0084: 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_009d: 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)
			try
			{
				RepoBanManager.Instance?.RefreshSteamLobbyMap();
				if ((Object)(object)SteamManager.instance == (Object)null)
				{
					return;
				}
				SteamId id = ((Lobby)(ref SteamManager.instance.currentLobby)).Id;
				if (!((SteamId)(ref id)).IsValid || SteamId.op_Implicit(((Lobby)(ref lobby)).Id) != SteamId.op_Implicit(((Lobby)(ref SteamManager.instance.currentLobby)).Id) || !((Lobby)(ref SteamManager.instance.currentLobby)).IsOwnedBy(SteamClient.SteamId))
				{
					return;
				}
				ulong value = friend.Id.Value;
				if (RepoBanManager.IsSteamIdBanned(value))
				{
					if (SteamLobbyKickUtil.TryKick(lobby, value))
					{
						Debug.Log((object)$"[RepoBan] Steam gate blocked SteamID {value} at lobby level");
					}
					else
					{
						Debug.Log((object)$"[RepoBan] Steam gate could not kick (API unavailable). Will enforce via Photon for SteamID {value}.");
					}
				}
			}
			catch (Exception ex)
			{
				if (RepoBanManager.VerboseLogs)
				{
					Debug.LogWarning((object)("[RepoBan] SteamLobbyGate.OnLobbyMemberJoined error: " + ex.Message));
				}
			}
		}

		private static void OnLobbyMemberLeft(Lobby lobby, Friend friend)
		{
			RepoBanManager.Instance?.RefreshSteamLobbyMap();
		}
	}
	[BepInPlugin("repo.ban.enforcer", "Repo Ban Enforcer", "1.9.3")]
	public class RepoBanEnforcerPlugin : BaseUnityPlugin
	{
		private enum Tab
		{
			Bans,
			Arcade
		}

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

			public static BuilderDelegate <>9__83_0;

			public static BuilderDelegate <>9__83_1;

			public static Func<Player, int> <>9__110_0;

			public static Func<KeyValuePair<ulong, string>, string> <>9__110_1;

			internal void <Start>b__83_0(Transform parent)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				MenuAPI.CreateREPOButton("<size=22><b>BAN LIST</b></size>", (Action)OpenUI, parent, new Vector2(420f, -40f));
				Debug.Log((object)"[RepoBan] MenuLib: added BAN LIST to Escape menu.");
			}

			internal void <Start>b__83_1(Transform parent)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				MenuAPI.CreateREPOButton("<size=22><b>BAN LIST</b></size>", (Action)OpenUI, parent, new Vector2(420f, -40f));
				Debug.Log((object)"[RepoBan] MenuLib: added BAN LIST to Lobby menu.");
			}

			internal int <DrawBanTab>b__110_0(Player p)
			{
				return p.ActorNumber;
			}

			internal string <DrawBanTab>b__110_1(KeyValuePair<ulong, string> k)
			{
				return k.Value;
			}
		}

		[CompilerGenerated]
		private sealed class <LoadDemoAudioAndPlay>d__99 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RepoBanEnforcerPlugin <>4__this;

			private string <path>5__1;

			private UnityWebRequest <req>5__2;

			private bool <ok>5__3;

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

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

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

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

			private bool MoveNext()
			{
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
						<>1__state = -1;
						<>4__this._demoTriedLoad = true;
						<path>5__1 = <>4__this.FindNearbyFile("omnidemo.mp3");
						if (!string.IsNullOrEmpty(<path>5__1))
						{
							<req>5__2 = UnityWebRequestMultimedia.GetAudioClip("file://" + <path>5__1, (AudioType)13);
							<>1__state = -3;
							<>2__current = <req>5__2.SendWebRequest();
							<>1__state = 1;
							return true;
						}
						break;
					case 1:
						<>1__state = -3;
						<ok>5__3 = !<req>5__2.isHttpError && !<req>5__2.isNetworkError;
						if (<ok>5__3)
						{
							try
							{
								<>4__this._demoClip = DownloadHandlerAudioClip.GetContent(<req>5__2);
							}
							catch
							{
								<>4__this._demoClip = null;
							}
						}
						<>m__Finally1();
						<req>5__2 = null;
						break;
					}
					if ((Object)(object)<>4__this._demoClip == (Object)null)
					{
						((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)"[RepoBan] omnidemo.mp3 not found or failed to load — using synth fallback.");
						<>4__this._demoClip = <>4__this.CreateDemoFallbackClip();
					}
					if ((Object)(object)<>4__this._demoAudio != (Object)null)
					{
						<>4__this._demoAudio.clip = <>4__this._demoClip;
						<>4__this._demoAudio.Play();
					}
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

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

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

		[CompilerGenerated]
		private sealed class <Start>d__83 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public RepoBanEnforcerPlugin <>4__this;

			private Exception <e>5__1;

			private string <steamId>5__2;

			private Exception <e>5__3;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<e>5__1 = null;
				<steamId>5__2 = null;
				<e>5__3 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Expected O, but got Unknown
				//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_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_0152: Expected O, but got Unknown
				//IL_016c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0171: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Expected O, but got Unknown
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_010e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((BaseUnityPlugin)<>4__this).Logger.LogInfo((object)"[RepoBan] Plugin starting…");
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					try
					{
						RepoBanPatcher.Apply(new Harmony("repo.ban.enforcer"));
						RepoBanManager.EnsureExists();
						SteamLobbyGate.EnsureRegistered();
					}
					catch (Exception ex)
					{
						<e>5__1 = ex;
						((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)$"[RepoBan] Init error: {<e>5__1}");
					}
					try
					{
						if (SteamClient.IsValid)
						{
							SteamId steamId = SteamClient.SteamId;
							<steamId>5__2 = ((object)(SteamId)(ref steamId)).ToString();
							if (!string.IsNullOrEmpty(<steamId>5__2))
							{
								if (PhotonNetwork.AuthValues == null)
								{
									PhotonNetwork.AuthValues = new AuthenticationValues();
								}
								PhotonNetwork.AuthValues.UserId = <steamId>5__2;
							}
							<steamId>5__2 = null;
						}
					}
					catch
					{
					}
					try
					{
						object obj2 = <>c.<>9__83_0;
						if (obj2 == null)
						{
							BuilderDelegate val = delegate(Transform parent)
							{
								//IL_002c: Unknown result type (might be due to invalid IL or missing references)
								MenuAPI.CreateREPOButton("<size=22><b>BAN LIST</b></size>", (Action)OpenUI, parent, new Vector2(420f, -40f));
								Debug.Log((object)"[RepoBan] MenuLib: added BAN LIST to Escape menu.");
							};
							<>c.<>9__83_0 = val;
							obj2 = (object)val;
						}
						MenuAPI.AddElementToEscapeMenu((BuilderDelegate)obj2);
						object obj3 = <>c.<>9__83_1;
						if (obj3 == null)
						{
							BuilderDelegate val2 = delegate(Transform parent)
							{
								//IL_002c: Unknown result type (might be due to invalid IL or missing references)
								MenuAPI.CreateREPOButton("<size=22><b>BAN LIST</b></size>", (Action)OpenUI, parent, new Vector2(420f, -40f));
								Debug.Log((object)"[RepoBan] MenuLib: added BAN LIST to Lobby menu.");
							};
							<>c.<>9__83_1 = val2;
							obj3 = (object)val2;
						}
						MenuAPI.AddElementToLobbyMenu((BuilderDelegate)obj3);
					}
					catch (Exception ex)
					{
						<e>5__3 = ex;
						((BaseUnityPlugin)<>4__this).Logger.LogWarning((object)("[RepoBan] MenuLib register failed: " + <e>5__3.Message));
					}
					return false;
				}
			}

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

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

		internal static ManualLogSource LogSrc;

		private bool _show;

		private bool _userManuallyClosed = false;

		private Rect _win = new Rect(40f, 140f, 980f, 520f);

		private Vector2 _scrollPlayers;

		private Vector2 _scrollBanned;

		private Vector2 _scrollSteam;

		private string _manualSteamBan = "";

		private GUIStyle _winStyle;

		private GUIStyle _boxStyle;

		private GUIStyle _labelStyle;

		private GUIStyle _labelHeaderStyle;

		private GUIStyle _buttonStyle;

		private GUIStyle _textFieldStyle;

		private GUIStyle _tabStyle;

		private GUIStyle _tabActiveStyle;

		private GUIStyle _thinLabelStyle;

		private Texture2D _texGlassWin;

		private Texture2D _texGlassPanel;

		private Texture2D _texBtn;

		private Texture2D _texBtnHover;

		private Texture2D _texBtnActive;

		private Texture2D _texLineRed;

		private Texture2D _texWhite;

		private Texture2D _texBorder;

		private Texture2D _texHighlight;

		private Texture2D _shadowBig;

		private Texture2D _shadowSmall;

		private Texture2D _omniIcon;

		private bool _stylesReady;

		private bool _triedIcon;

		private GUIStyle _hiddenBtnStyle;

		private readonly Color _cText = new Color(0.98f, 0.99f, 1f, 0.98f);

		private readonly Color _cTextSoft = new Color(0.98f, 0.99f, 1f, 0.85f);

		private readonly Color _cGlass = new Color(0.08f, 0.09f, 0.12f, 0.58f);

		private readonly Color _cGlassPanel = new Color(0.1f, 0.12f, 0.16f, 0.42f);

		private readonly Color _cBorder = new Color(1f, 1f, 1f, 0.08f);

		private readonly Color _cHighlight = new Color(1f, 1f, 1f, 0.06f);

		private readonly Color _cRed = new Color(0.98f, 0.22f, 0.28f, 0.85f);

		private readonly Color _cRedHover = new Color(1f, 0.35f, 0.4f, 0.95f);

		private readonly Color _cRedActive = new Color(0.85f, 0.1f, 0.16f, 0.95f);

		private Tab _activeTab = Tab.Bans;

		private bool _pongInit;

		private bool _pongPaused = true;

		private int _pongLeftScore;

		private int _pongRightScore;

		private float _paddleLeftY = 0.5f;

		private float _paddleRightY = 0.5f;

		private float _ballX = 0.5f;

		private float _ballY = 0.5f;

		private float _ballVX = 0.45f;

		private float _ballVY = 0.33f;

		private const float PADDLE_H = 0.18f;

		private const float PADDLE_W = 0.015f;

		private const float BALL_R = 0.012f;

		private const float PADDLE_SPEED = 0.7f;

		private AudioSource _pongAudio;

		private AudioClip _hitClip;

		private bool _cracktroActive = false;

		private float _cracktroStart;

		private float _scrollX;

		private string _scrollMsg = "   Shout out to the R.E.P.O modding Discord and all of the amazing people in there.   We fight for the Users.   I am the Queen of Cursed.   ";

		private AudioSource _demoAudio;

		private AudioClip _demoClip;

		private float[] _spec = new float[64];

		private float _vu;

		private float _vuSmoothed;

		private float _bassLevel;

		private float _bassSmoothed;

		private GUIStyle _demoTitleStyle;

		private GUIStyle _demoScrollStyle;

		private GUIStyle _demoSmallStyle;

		private Texture2D _texScanline;

		private bool _demoTriedLoad;

		private const string DemoFileName = "omnidemo.mp3";

		public static RepoBanEnforcerPlugin Instance { get; private set; }

		public static void OpenUI()
		{
			if ((Object)(object)Instance == (Object)null)
			{
				Instance = Object.FindObjectOfType<RepoBanEnforcerPlugin>();
			}
			if ((Object)(object)Instance != (Object)null)
			{
				Instance._show = true;
				Instance._userManuallyClosed = false;
				Instance._pongPaused = Instance._activeTab != Tab.Arcade;
			}
		}

		public static void ResetManualCloseFlag()
		{
			if ((Object)(object)Instance != (Object)null)
			{
				Instance._userManuallyClosed = false;
			}
		}

		private void Awake()
		{
			Instance = this;
			LogSrc = ((BaseUnityPlugin)this).Logger;
			LoadOmniIcon();
			EnsureAudio();
		}

		[IteratorStateMachine(typeof(<Start>d__83))]
		private IEnumerator Start()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Start>d__83(0)
			{
				<>4__this = this
			};
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)287))
			{
				_show = !_show;
				_userManuallyClosed = !_show;
				if (!_show)
				{
					_pongPaused = true;
					StopCracktro();
				}
				return;
			}
			if (Input.GetKeyDown((KeyCode)288))
			{
				RepoBanManager.DumpDebugInfo();
			}
			if (_show && _activeTab == Tab.Arcade && !_pongPaused)
			{
				if (!_pongInit)
				{
					InitPong();
				}
				float dt = Mathf.Clamp(Time.unscaledDeltaTime, 0f, 0.05f);
				StepPong(dt);
			}
			if (!_cracktroActive || !((Object)(object)_demoAudio != (Object)null) || !((Object)(object)_demoAudio.clip != (Object)null))
			{
				return;
			}
			try
			{
				_demoAudio.GetSpectrumData(_spec, 0, (FFTWindow)5);
				float num = 0f;
				int num2 = Mathf.Min(16, _spec.Length);
				for (int i = 0; i < num2; i++)
				{
					num += _spec[i];
				}
				_vu = Mathf.Clamp01(num * 18f);
				_vuSmoothed = Mathf.Lerp(_vuSmoothed, _vu, 0.2f);
				float num3 = 0f;
				int num4 = Mathf.Min(4, _spec.Length);
				for (int j = 0; j < num4; j++)
				{
					num3 += _spec[j];
				}
				_bassLevel = Mathf.Clamp01(num3 * 2f);
				_bassSmoothed = Mathf.Lerp(_bassSmoothed, _bassLevel, 0.15f);
			}
			catch
			{
			}
		}

		private bool IsPauseLike()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			return Time.timeScale == 0f || (int)Cursor.lockState != 1;
		}

		private Texture2D MakeSolid(int w, int h, Color c)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			Color[] array = (Color[])(object)new Color[w * h];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = c;
			}
			Texture2D val = new Texture2D(w, h, (TextureFormat)4, false);
			val.SetPixels(array);
			val.Apply();
			((Texture)val).wrapMode = (TextureWrapMode)1;
			return val;
		}

		private Texture2D MakeVerticalGradient(int w, int h, Color top, Color bottom)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0026: 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_002a: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			Texture2D val = new Texture2D(w, h, (TextureFormat)4, false);
			for (int i = 0; i < h; i++)
			{
				float num = (float)i / Mathf.Max(1f, (float)h - 1f);
				Color val2 = Color.Lerp(top, bottom, num);
				for (int j = 0; j < w; j++)
				{
					val.SetPixel(j, i, val2);
				}
			}
			val.Apply();
			((Texture)val).wrapMode = (TextureWrapMode)1;
			return val;
		}

		private Texture2D MakeRadialShadow(int size, float softness = 1.6f, float alpha = 0.35f)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0013: 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_0022: 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_003f: 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)
			Texture2D val = new Texture2D(size, size, (TextureFormat)4, false);
			Vector2 val2 = new Vector2((float)(size - 1), (float)(size - 1)) * 0.5f;
			float magnitude = ((Vector2)(ref val2)).magnitude;
			for (int i = 0; i < size; i++)
			{
				for (int j = 0; j < size; j++)
				{
					float num = Vector2.Distance(new Vector2((float)j, (float)i), val2) / magnitude;
					float num2 = Mathf.Pow(Mathf.Clamp01(1f - num), softness) * alpha;
					val.SetPixel(j, i, new Color(0f, 0f, 0f, num2));
				}
			}
			val.Apply();
			((Texture)val).wrapMode = (TextureWrapMode)1;
			return val;
		}

		private void EnsureStyles()
		{
			//IL_0059: 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_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: 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)
			//IL_0321: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_034a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Unknown result type (might be due to invalid IL or missing references)
			//IL_036e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c9: Expected O, but got Unknown
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Expected O, but got Unknown
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ed: Expected O, but got Unknown
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_040b: Expected O, but got Unknown
			//IL_0416: Unknown result type (might be due to invalid IL or missing references)
			//IL_041b: Unknown result type (might be due to invalid IL or missing references)
			//IL_042d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: Unknown result type (might be due to invalid IL or missing references)
			//IL_0458: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Unknown result type (might be due to invalid IL or missing references)
			//IL_0472: Expected O, but got Unknown
			//IL_0473: Unknown result type (might be due to invalid IL or missing references)
			//IL_047a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0484: Expected O, but got Unknown
			//IL_0485: Unknown result type (might be due to invalid IL or missing references)
			//IL_0492: Expected O, but got Unknown
			//IL_049d: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c1: Expected O, but got Unknown
			//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_04df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0506: Expected O, but got Unknown
			//IL_050d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0512: Unknown result type (might be due to invalid IL or missing references)
			//IL_051f: Expected O, but got Unknown
			//IL_052a: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0541: Unknown result type (might be due to invalid IL or missing references)
			//IL_0547: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_056a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0575: Unknown result type (might be due to invalid IL or missing references)
			//IL_0587: Unknown result type (might be due to invalid IL or missing references)
			//IL_058d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0598: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05aa: Expected O, but got Unknown
			//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b8: Expected O, but got Unknown
			//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0605: Unknown result type (might be due to invalid IL or missing references)
			//IL_0615: Expected O, but got Unknown
			//IL_061c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0626: Expected O, but got Unknown
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0637: Expected O, but got Unknown
			//IL_0642: Unknown result type (might be due to invalid IL or missing references)
			//IL_0647: Unknown result type (might be due to invalid IL or missing references)
			//IL_0658: Unknown result type (might be due to invalid IL or missing references)
			//IL_0672: Unknown result type (might be due to invalid IL or missing references)
			//IL_067d: Unknown result type (might be due to invalid IL or missing references)
			//IL_068e: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06de: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f8: Expected O, but got Unknown
			//IL_06f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0708: Expected O, but got Unknown
			//IL_0709: Unknown result type (might be due to invalid IL or missing references)
			//IL_070e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0718: Expected O, but got Unknown
			//IL_071e: Expected O, but got Unknown
			if (!_stylesReady)
			{
				_texGlassWin = MakeVerticalGradient(4, 64, new Color(_cGlass.r + 0.02f, _cGlass.g + 0.02f, _cGlass.b + 0.03f, _cGlass.a + 0.04f), new Color(_cGlass.r, _cGlass.g, _cGlass.b, _cGlass.a));
				_texGlassPanel = MakeVerticalGradient(4, 64, new Color(_cGlassPanel.r + 0.02f, _cGlassPanel.g + 0.02f, _cGlassPanel.b + 0.03f, _cGlassPanel.a + 0.03f), _cGlassPanel);
				_texBorder = MakeSolid(2, 2, _cBorder);
				_texHighlight = MakeSolid(2, 2, _cHighlight);
				_texBtn = MakeVerticalGradient(4, 32, new Color(_cRed.r, _cRed.g, _cRed.b, _cRed.a), new Color(_cRed.r * 0.9f, _cRed.g * 0.9f, _cRed.b * 0.9f, _cRed.a));
				_texBtnHover = MakeVerticalGradient(4, 32, _cRedHover, new Color(_cRedHover.r * 0.88f, _cRedHover.g * 0.88f, _cRedHover.b * 0.88f, _cRedHover.a));
				_texBtnActive = MakeVerticalGradient(4, 32, _cRedActive, new Color(_cRedActive.r * 0.85f, _cRedActive.g * 0.85f, _cRedActive.b * 0.85f, _cRedActive.a));
				_texLineRed = MakeSolid(2, 2, new Color(1f, 0.13f, 0.18f, 0.7f));
				_texWhite = MakeSolid(2, 2, new Color(1f, 1f, 1f, 0.92f));
				_shadowBig = MakeRadialShadow(256, 2f, 0.32f);
				_shadowSmall = MakeRadialShadow(128, 2.2f, 0.25f);
				_texScanline = MakeVerticalGradient(2, 4, new Color(1f, 1f, 1f, 0.06f), new Color(1f, 1f, 1f, 0f));
				GUIStyle val = new GUIStyle(GUI.skin.window);
				val.normal.background = _texGlassWin;
				val.normal.textColor = _cText;
				val.active.background = _texGlassWin;
				val.active.textColor = _cText;
				val.onNormal.background = _texGlassWin;
				val.onNormal.textColor = _cText;
				val.onActive.background = _texGlassWin;
				val.onActive.textColor = _cText;
				val.border = new RectOffset(12, 12, 24, 14);
				val.padding = new RectOffset(12, 12, 32, 12);
				val.margin = new RectOffset(0, 0, 0, 0);
				val.fontStyle = (FontStyle)1;
				val.richText = true;
				val.alignment = (TextAnchor)0;
				_winStyle = val;
				GUIStyle val2 = new GUIStyle(GUI.skin.box);
				val2.normal.background = _texGlassPanel;
				val2.normal.textColor = _cText;
				val2.active.background = _texGlassPanel;
				val2.active.textColor = _cText;
				val2.margin = new RectOffset(2, 2, 2, 2);
				val2.padding = new RectOffset(10, 10, 8, 8);
				val2.richText = true;
				_boxStyle = val2;
				GUIStyle val3 = new GUIStyle(GUI.skin.label);
				val3.normal.textColor = _cText;
				val3.richText = true;
				_labelStyle = val3;
				GUIStyle val4 = new GUIStyle(_labelStyle);
				val4.normal.textColor = _cTextSoft;
				val4.fontSize = Mathf.RoundToInt((float)GUI.skin.label.fontSize * 0.95f);
				_thinLabelStyle = val4;
				_labelHeaderStyle = new GUIStyle(_labelStyle)
				{
					fontStyle = (FontStyle)1
				};
				GUIStyle val5 = new GUIStyle(GUI.skin.button);
				val5.normal.background = _texBtn;
				val5.normal.textColor = Color.white;
				val5.hover.background = _texBtnHover;
				val5.hover.textColor = Color.white;
				val5.active.background = _texBtnActive;
				val5.active.textColor = Color.white;
				val5.padding = new RectOffset(12, 12, 8, 10);
				val5.richText = true;
				_buttonStyle = val5;
				GUIStyle val6 = new GUIStyle(GUI.skin.textField);
				val6.normal.background = _texGlassPanel;
				val6.normal.textColor = _cText;
				val6.focused.background = _texGlassPanel;
				val6.focused.textColor = _cText;
				_textFieldStyle = val6;
				_tabStyle = new GUIStyle(_buttonStyle);
				_tabActiveStyle = new GUIStyle(_buttonStyle);
				GUIStyle val7 = new GUIStyle(GUI.skin.button);
				val7.normal.background = Texture2D.blackTexture;
				val7.normal.textColor = new Color(0f, 0f, 0f, 0f);
				val7.hover.background = Texture2D.blackTexture;
				val7.hover.textColor = new Color(0f, 0f, 0f, 0f);
				val7.active.background = Texture2D.blackTexture;
				val7.active.textColor = new Color(0f, 0f, 0f, 0f);
				val7.border = new RectOffset(0, 0, 0, 0);
				val7.margin = new RectOffset(0, 0, 0, 0);
				val7.padding = new RectOffset(0, 0, 0, 0);
				_hiddenBtnStyle = val7;
				_hiddenBtnStyle.normal.background = null;
				_hiddenBtnStyle.hover.background = null;
				_hiddenBtnStyle.active.background = null;
				_stylesReady = true;
			}
		}

		private void LoadOmniIcon()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			if (_triedIcon)
			{
				return;
			}
			_triedIcon = true;
			try
			{
				string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
				string text = Path.Combine(directoryName ?? "", "omni.png");
				if (!File.Exists(text))
				{
					text = Path.Combine(Paths.ConfigPath, "omni.png");
				}
				if (File.Exists(text))
				{
					byte[] array = File.ReadAllBytes(text);
					_omniIcon = new Texture2D(2, 2, (TextureFormat)4, false);
					ImageConversion.LoadImage(_omniIcon, array, false);
					_omniIcon.Apply();
					((BaseUnityPlugin)this).Logger.LogInfo((object)("[RepoBan] Loaded icon: " + text));
				}
				else
				{
					((BaseUnityPlugin)this).Logger.LogInfo((object)"[RepoBan] omni.png not found (optional).");
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("[RepoBan] Icon load failed: " + ex.Message));
			}
		}

		private void EnsureAudio()
		{
			if (!((Object)(object)_pongAudio != (Object)null))
			{
				_pongAudio = ((Component)this).gameObject.AddComponent<AudioSource>();
				_pongAudio.playOnAwake = false;
				_pongAudio.spatialBlend = 0f;
				_pongAudio.volume = 0.25f;
				_hitClip = CreateClickClip(0.035f, 920f);
			}
		}

		private AudioClip CreateClickClip(float duration, float frequency)
		{
			int num = 44100;
			int num2 = Mathf.CeilToInt(duration * (float)num);
			AudioClip val = AudioClip.Create("pong_click", num2, 1, num, false);
			float[] array = new float[num2];
			for (int i = 0; i < num2; i++)
			{
				float num3 = (float)i / (float)num;
				float num4 = Mathf.Exp(-24f * num3);
				array[i] = Mathf.Sin(MathF.PI * 2f * frequency * num3) * num4 * 0.35f;
			}
			val.SetData(array, 0);
			return val;
		}

		private void PlayHitSfx()
		{
			if ((Object)(object)_pongAudio != (Object)null && (Object)(object)_hitClip != (Object)null)
			{
				_pongAudio.PlayOneShot(_hitClip, 0.9f);
			}
		}

		private void StartCracktro()
		{
			_cracktroActive = true;
			_cracktroStart = Time.unscaledTime;
			_scrollX = 0f;
			_vu = (_vuSmoothed = 0f);
			_bassLevel = (_bassSmoothed = 0f);
			if ((Object)(object)_demoAudio == (Object)null)
			{
				_demoAudio = ((Component)this).gameObject.AddComponent<AudioSource>();
				_demoAudio.playOnAwake = false;
				_demoAudio.loop = true;
				_demoAudio.spatialBlend = 0f;
				_demoAudio.volume = 0.92f;
			}
			if (!_demoTriedLoad)
			{
				((MonoBehaviour)this).StartCoroutine(LoadDemoAudioAndPlay());
				return;
			}
			if ((Object)(object)_demoClip == (Object)null)
			{
				_demoClip = CreateDemoFallbackClip();
			}
			_demoAudio.clip = _demoClip;
			_demoAudio.Play();
		}

		private void DrawRotatingCubes(Vector2 center, Vector2 textSize, float time, float bassLevel)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			float num = (textSize.x + textSize.y) * 0.3f + bassLevel * 20f;
			float size = 12f + bassLevel * 8f;
			int num2 = 6;
			Vector2 pos = default(Vector2);
			for (int i = 0; i < num2; i++)
			{
				float num3 = (float)i / (float)num2 * 2f * MathF.PI;
				float num4 = 0.8f + bassLevel * 1.2f;
				float num5 = time * num4 + num3;
				((Vector2)(ref pos))..ctor(center.x + Mathf.Cos(num5) * num, center.y + Mathf.Sin(num5) * num * 0.6f);
				float rotation = time * 2f + num3;
				DrawPseudo3DCube(pos, size, rotation, bassLevel);
			}
		}

		private void DrawPseudo3DCube(Vector2 pos, float size, float rotation, float bassLevel)
		{
			//IL_0015: 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_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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: 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_00a2: 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_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: 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_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: 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_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: 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_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: 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_0297: Unknown result type (might be due to invalid IL or missing references)
			Color val = Color.Lerp(new Color(0.3f, 0.3f, 0.8f, 0.7f), new Color(1f, 0.2f, 0.8f, 0.9f), bassLevel);
			Color val2 = Color.Lerp(new Color(0.6f, 0.6f, 1f, 0.8f), new Color(1f, 0.8f, 0.2f, 1f), bassLevel);
			float num = size * 0.5f;
			Vector2 val3 = default(Vector2);
			((Vector2)(ref val3))..ctor(Mathf.Cos(rotation) * num * 0.3f, Mathf.Sin(rotation) * num * 0.3f);
			Rect val4 = default(Rect);
			((Rect)(ref val4))..ctor(pos.x - num + val3.x, pos.y - num + val3.y, size, size);
			GUI.color = new Color(val.r * 0.6f, val.g * 0.6f, val.b * 0.6f, val.a * 0.8f);
			GUI.DrawTexture(val4, (Texture)(object)_texGlassPanel);
			Rect val5 = default(Rect);
			((Rect)(ref val5))..ctor(pos.x - num, pos.y - num, size, size);
			GUI.color = val;
			GUI.DrawTexture(val5, (Texture)(object)_texGlassPanel);
			GUI.color = val2;
			DrawRectBorder(val5, 1f, (Texture)(object)_texBorder);
			GUI.color = new Color(val2.r, val2.g, val2.b, 0.6f);
			Vector2[] array = (Vector2[])(object)new Vector2[4]
			{
				new Vector2(((Rect)(ref val5)).xMin, ((Rect)(ref val5)).yMin),
				new Vector2(((Rect)(ref val5)).xMax, ((Rect)(ref val5)).yMin),
				new Vector2(((Rect)(ref val5)).xMax, ((Rect)(ref val5)).yMax),
				new Vector2(((Rect)(ref val5)).xMin, ((Rect)(ref val5)).yMax)
			};
			Vector2[] array2 = (Vector2[])(object)new Vector2[4]
			{
				new Vector2(((Rect)(ref val4)).xMin, ((Rect)(ref val4)).yMin),
				new Vector2(((Rect)(ref val4)).xMax, ((Rect)(ref val4)).yMin),
				new Vector2(((Rect)(ref val4)).xMax, ((Rect)(ref val4)).yMax),
				new Vector2(((Rect)(ref val4)).xMin, ((Rect)(ref val4)).yMax)
			};
			for (int i = 0; i < 4; i++)
			{
				DrawLine(array[i], array2[i], _texBorder, 1f);
			}
			GUI.color = Color.white;
		}

		private void DrawLine(Vector2 start, Vector2 end, Texture2D tex, float thickness)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: 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_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: 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_0033: 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_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_0046: 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_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_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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)
			Vector2 val = end - start;
			Vector2 normalized = ((Vector2)(ref val)).normalized;
			float num = Vector2.Distance(start, end);
			float num2 = Mathf.Atan2(normalized.y, normalized.x) * 57.29578f;
			Vector2 val2 = (start + end) * 0.5f;
			Rect val3 = default(Rect);
			((Rect)(ref val3))..ctor(val2.x - num * 0.5f, val2.y - thickness * 0.5f, num, thickness);
			Matrix4x4 matrix = GUI.matrix;
			GUIUtility.RotateAroundPivot(num2, val2);
			GUI.DrawTexture(val3, (Texture)(object)tex);
			GUI.matrix = matrix;
		}

		private void StopCracktro()
		{
			_cracktroActive = false;
			if ((Object)(object)_demoAudio != (Object)null)
			{
				_demoAudio.Stop();
			}
		}

		[IteratorStateMachine(typeof(<LoadDemoAudioAndPlay>d__99))]
		private IEnumerator LoadDemoAudioAndPlay()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadDemoAudioAndPlay>d__99(0)
			{
				<>4__this = this
			};
		}

		private string FindNearbyFile(string filename)
		{
			try
			{
				string directoryName = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
				string text = Path.Combine(directoryName ?? "", filename);
				if (File.Exists(text))
				{
					return text;
				}
				string text2 = Path.Combine(Paths.ConfigPath, filename);
				if (File.Exists(text2))
				{
					return text2;
				}
				string text3 = Path.Combine(Application.streamingAssetsPath ?? "", filename);
				if (File.Exists(text3))
				{
					return text3;
				}
			}
			catch
			{
			}
			return null;
		}

		private AudioClip CreateDemoFallbackClip()
		{
			int num = 44100;
			float num2 = 60f;
			int num3 = Mathf.CeilToInt(num2 * (float)num);
			AudioClip val = AudioClip.Create("omnidemo_fallback", num3, 1, num, false);
			float[] array = new float[num3];
			float[] array2 = new float[8] { 110f, 146.83f, 164.81f, 220f, 246.94f, 329.63f, 196f, 174.61f };
			for (int i = 0; i < num3; i++)
			{
				float num4 = (float)i / (float)num;
				float num5 = array2[i / (num / 2) % array2.Length];
				float num6 = Mathf.Sign(Mathf.Sin(MathF.PI * 2f * num5 * num4));
				float num7 = 2f * (num4 * num5 - Mathf.Floor(0.5f + num4 * num5));
				float num8 = Mathf.Clamp01(1f - Mathf.Repeat(num4, 0.5f) * 1.6f);
				float num9 = (num6 * 0.45f + num7 * 0.25f) * num8;
				float num10 = Mathf.Repeat(num4, 0.5f);
				num9 += Mathf.Exp((0f - num10) * 24f) * 0.25f * Mathf.Sin(MathF.PI * 100f * num4);
				array[i] = num9 * 0.5f;
			}
			val.SetData(array, 0);
			return val;
		}

		private void OnGUI()
		{
			//IL_001c: 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_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: 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_006c: Expected O, but got Unknown
			//IL_0067: 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_0073: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Expected O, but got Unknown
			//IL_00da: 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_00e6: 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_010a: Unknown result type (might be due to invalid IL or missing references)
			EnsureStyles();
			if (!_show)
			{
				return;
			}
			DrawWindowShadow(_win, (Texture)(object)_shadowBig, 18f);
			if (!PhotonNetwork.InRoom)
			{
				_win = GUILayout.Window(987123, _win, new WindowFunction(DrawNoRoom), "Repo Ban — not in room", _winStyle, Array.Empty<GUILayoutOption>());
				DrawHeaderBevel(_win);
				DrawTopIcon(_win);
				if (_cracktroActive)
				{
					DrawCracktroOverlay(_win);
				}
			}
			else
			{
				_win = GUILayout.Window(987122, _win, new WindowFunction(DrawWindow), PhotonNetwork.IsMasterClient ? "Ban List (Host) — F6 | F7=Debug" : "Ban List (Viewer) — F6 | F7=Debug", _winStyle, Array.Empty<GUILayoutOption>());
				DrawHeaderBevel(_win);
				DrawTopIcon(_win);
				if (_cracktroActive)
				{
					DrawCracktroOverlay(_win);
				}
			}
		}

		private void DrawTopIcon(Rect win)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_omniIcon == (Object)null))
			{
				float num = 52f;
				float num2 = 8f;
				Rect val = default(Rect);
				((Rect)(ref val))..ctor(((Rect)(ref win)).x + ((Rect)(ref win)).width - num - num2, ((Rect)(ref win)).y + num2, num, num);
				GUI.DrawTexture(val, (Texture)(object)_omniIcon, (ScaleMode)2, true);
			}
		}

		private void DrawHeaderBevel(Rect win)
		{
			//IL_0034: 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)
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref win)).x + 6f, ((Rect)(ref win)).y + 6f, ((Rect)(ref win)).width - 12f, 2f);
			GUI.DrawTexture(val, (Texture)(object)_texHighlight);
			Rect r = default(Rect);
			((Rect)(ref r))..ctor(((Rect)(ref win)).x + 3f, ((Rect)(ref win)).y + 3f, ((Rect)(ref win)).width - 6f, ((Rect)(ref win)).height - 6f);
			DrawRectBorder(r, 1f, (Texture)(object)_texBorder);
		}

		private void DrawWindowShadow(Rect r, Texture tex, float padding)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref r)).x - padding, ((Rect)(ref r)).y - padding, ((Rect)(ref r)).width + padding * 2f, ((Rect)(ref r)).height + padding * 2f);
			GUI.DrawTexture(val, tex, (ScaleMode)0, true);
		}

		private void DrawRectBorder(Rect r, float thickness, Texture tex)
		{
			//IL_0079: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref r)).x, ((Rect)(ref r)).y, ((Rect)(ref r)).width, thickness);
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(((Rect)(ref r)).x, ((Rect)(ref r)).yMax - thickness, ((Rect)(ref r)).width, thickness);
			Rect val3 = default(Rect);
			((Rect)(ref val3))..ctor(((Rect)(ref r)).x, ((Rect)(ref r)).y, thickness, ((Rect)(ref r)).height);
			Rect val4 = default(Rect);
			((Rect)(ref val4))..ctor(((Rect)(ref r)).xMax - thickness, ((Rect)(ref r)).y, thickness, ((Rect)(ref r)).height);
			GUI.DrawTexture(val, tex);
			GUI.DrawTexture(val2, tex);
			GUI.DrawTexture(val3, tex);
			GUI.DrawTexture(val4, tex);
		}

		private void DrawNoRoom(int id)
		{
			//IL_0065: 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_009e: Unknown result type (might be due to invalid IL or missing references)
			DrawOmniHiddenButton();
			GUILayout.Label("Join/Create a room to manage bans.", _labelStyle, Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Close", _buttonStyle, Array.Empty<GUILayoutOption>()))
			{
				_show = false;
				_userManuallyClosed = true;
				_pongPaused = true;
				StopCracktro();
			}
			GUI.DragWindow();
			Rect rect = GUILayoutUtility.GetRect(1f, 8f);
			((Rect)(ref rect)).height = 2f;
			((Rect)(ref rect)).x = 6f;
			((Rect)(ref rect)).width = ((Rect)(ref _win)).width - 12f;
			GUI.DrawTexture(rect, (Texture)(object)_texLineRed);
		}

		private void DrawWindow(int id)
		{
			//IL_01b8: 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_01f1: Unknown result type (might be due to invalid IL or missing references)
			DrawOmniHiddenButton();
			bool isMasterClient = PhotonNetwork.IsMasterClient;
			if (!isMasterClient)
			{
				GUILayout.Label("<color=#FFEE99>You are not the host — only the host enforces bans.</color>", _thinLabelStyle, Array.Empty<GUILayoutOption>());
			}
			GUILayout.Space(4f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Bans", (_activeTab == Tab.Bans) ? _tabActiveStyle : _tabStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) }))
			{
				_activeTab = Tab.Bans;
				_pongPaused = true;
				StopCracktro();
			}
			if (GUILayout.Button("Arcade (Pong)", (_activeTab == Tab.Arcade) ? _tabActiveStyle : _tabStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(170f) }))
			{
				_activeTab = Tab.Arcade;
				if (!_pongInit)
				{
					InitPong();
				}
				_pongPaused = false;
				StopCracktro();
			}
			GUILayout.FlexibleSpace();
			GUILayout.EndHorizontal();
			GUILayout.Space(6f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button("Close", _buttonStyle, Array.Empty<GUILayoutOption>()))
			{
				_show = false;
				_userManuallyClosed = true;
				_pongPaused = true;
				StopCracktro();
			}
			if (GUILayout.Button("Debug Dump (F7)", _buttonStyle, Array.Empty<GUILayoutOption>()))
			{
				RepoBanManager.DumpDebugInfo();
			}
			GUILayout.FlexibleSpace();
			GUI.enabled = isMasterClient;
			if (GUILayout.Button("Clear All Bans", _buttonStyle, Array.Empty<GUILayoutOption>()))
			{
				RepoBanManager.ClearAllLocalBans();
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			Rect rect = GUILayoutUtility.GetRect(1f, 10f);
			((Rect)(ref rect)).height = 2f;
			((Rect)(ref rect)).x = 6f;
			((Rect)(ref rect)).width = ((Rect)(ref _win)).width - 12f;
			GUI.DrawTexture(rect, (Texture)(object)_texLineRed);
			GUILayout.Space(4f);
			if (_activeTab == Tab.Arcade)
			{
				DrawPongTab();
			}
			else
			{
				DrawBanTab(isMasterClient);
			}
			GUI.DragWindow();
		}

		private void DrawOmniHiddenButton()
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref _win)).width - 52f - 8f, 8f, 52f, 52f);
			if (GUI.Button(val, GUIContent.none, _hiddenBtnStyle))
			{
				if (_cracktroActive)
				{
					StopCracktro();
				}
				else
				{
					StartCracktro();
				}
			}
		}

		private void DrawBanTab(bool isMaster)
		{
			//IL_009f: 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_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_00db: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_044e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_0465: Unknown result type (might be due to invalid IL or missing references)
			//IL_046a: Unknown result type (might be due to invalid IL or missing references)
			//IL_048a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a7: Unknown result type (might be due to invalid IL or missing references)
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("<b>Players in Room (Steam)</b>", _labelHeaderStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(420f) });
			GUILayout.Label("<b>Banned (Steam)</b>", _labelHeaderStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(260f) });
			GUILayout.Label("<b>Steam Lobby Members</b>", _labelHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(420f) });
			Rect rect = GUILayoutUtility.GetRect(0f, 0f);
			float x = ((Rect)(ref rect)).x;
			rect = GUILayoutUtility.GetRect(0f, 0f);
			DrawPanelShadow(x, ((Rect)(ref rect)).y, 420f, 360f, (Texture)(object)_shadowSmall);
			_scrollPlayers = GUILayout.BeginScrollView(_scrollPlayers, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(350f) });
			Player[] array = PhotonNetwork.PlayerList.OrderBy((Player p) => p.ActorNumber).ToArray();
			Player[] array2 = array;
			foreach (Player val in array2)
			{
				GUILayout.BeginVertical(_boxStyle, Array.Empty<GUILayoutOption>());
				string text = RepoBanManager.Instance.ResolveSteam64For(val) ?? "Unknown";
				ulong result;
				bool flag = ulong.TryParse(text, out result);
				bool flag2 = flag && RepoBanManager.IsSteamIdBanned(result);
				string arg = (flag2 ? "#FF3B3B" : (val.IsLocal ? "#77E3FF" : "#FFFFFF"));
				GUILayout.Label($"<color={arg}><b>#{val.ActorNumber} — {val.NickName}</b></color>", _labelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label("  Steam64: '<b>" + text + "</b>'", _thinLabelStyle, Array.Empty<GUILayoutOption>());
				if (flag2)
				{
					GUILayout.Label("<color=#FF4D4D>  ⚠ BANNED</color>", _thinLabelStyle, Array.Empty<GUILayoutOption>());
				}
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
				GUI.enabled = isMaster && !val.IsLocal && flag;
				if (GUILayout.Button("BAN (Steam)", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) }))
				{
					RepoBanManager.BanBySteamId(result, val.NickName);
				}
				GUI.enabled = true;
				GUILayout.EndHorizontal();
				GUILayout.EndVertical();
				GUILayout.Space(3f);
			}
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
			GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(260f) });
			rect = GUILayoutUtility.GetRect(0f, 0f);
			float x2 = ((Rect)(ref rect)).x;
			rect = GUILayoutUtility.GetRect(0f, 0f);
			DrawPanelShadow(x2, ((Rect)(ref rect)).y, 260f, 360f, (Texture)(object)_shadowSmall);
			_scrollBanned = GUILayout.BeginScrollView(_scrollBanned, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(350f) });
			List<string> list = RepoBanManager.LocalSteamKeysSnapshot();
			foreach (string item in list)
			{
				GUILayout.BeginVertical(_boxStyle, Array.Empty<GUILayoutOption>());
				string text2 = (item.Contains(":") ? item.Substring(item.IndexOf(':') + 1) : item);
				GUILayout.Label("<b>Steam64:</b> " + text2, _labelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
				GUI.enabled = isMaster;
				if (GUILayout.Button("Remove", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(100f) }))
				{
					RepoBanManager.RemoveSteamKey(item);
				}
				GUI.enabled = true;
				GUILayout.EndHorizontal();
				GUILayout.EndVertical();
				GUILayout.Space(3f);
			}
			GUILayout.EndScrollView();
			GUILayout.EndVertical();
			GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
			rect = GUILayoutUtility.GetRect(0f, 0f);
			float x3 = ((Rect)(ref rect)).x;
			rect = GUILayoutUtility.GetRect(0f, 0f);
			DrawPanelShadow(x3, ((Rect)(ref rect)).y, 280f, 360f, (Texture)(object)_shadowSmall);
			_scrollSteam = GUILayout.BeginScrollView(_scrollSteam, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(350f) });
			Dictionary<ulong, string> source = RepoBanManager.SteamLobbySnapshot();
			foreach (KeyValuePair<ulong, string> item2 in source.OrderBy((KeyValuePair<ulong, string> k) => k.Value))
			{
				GUILayout.BeginVertical(_boxStyle, Array.Empty<GUILayoutOption>());
				GUILayout.Label($"{item2.Value}  <i>({item2.Key})</i>", _labelStyle, Array.Empty<GUILayoutOption>());
				GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
				GUILayout.FlexibleSpace();
				GUI.enabled = isMaster;
				if (GUILayout.Button("BAN (Steam)", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(120f) }))
				{
					RepoBanManager.BanBySteamId(item2.Key, item2.Value);
				}
				GUI.enabled = true;
				GUILayout.EndHorizontal();
				GUILayout.EndVertical();
				GUILayout.Space(3f);
			}
			GUILayout.EndScrollView();
			GUILayout.Space(6f);
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			GUILayout.Label("Manual Steam64:", _labelStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(130f) });
			_manualSteamBan = GUILayout.TextField(_manualSteamBan ?? "", _textFieldStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(200f) });
			GUI.enabled = isMaster;
			if (GUILayout.Button("Ban by Steam64", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(160f) }) && ulong.TryParse(_manualSteamBan, out var result2))
			{
				RepoBanManager.BanBySteamId(result2);
				_manualSteamBan = "";
			}
			GUI.enabled = true;
			GUILayout.EndHorizontal();
			GUILayout.EndVertical();
			GUILayout.EndHorizontal();
			GUILayout.Space(6f);
			GUILayout.Label(string.Format("<b>Status:</b> {0} local steam bans | Host: {1}", RepoBanManager.LocalSteamKeysSnapshot().Count, isMaster ? "YES" : "NO"), _thinLabelStyle, Array.Empty<GUILayoutOption>());
			GUILayout.Label("<i>Tip: If a player shows 'Unknown', wait a moment or use the Steam Lobby panel/manual Steam64 ban. F7 dumps debug.</i>", _thinLabelStyle, Array.Empty<GUILayoutOption>());
		}

		private void DrawPanelShadow(float x, float y, float w, float h, Texture shadow)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			float num = 8f;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(x + num, y + num, w - num * 0.5f, h - num * 0.5f);
			GUI.DrawTexture(val, shadow, (ScaleMode)0, true);
		}

		private void InitPong()
		{
			_pongInit = true;
			_paddleLeftY = (_paddleRightY = 0.5f);
			_ballX = 0.5f;
			_ballY = 0.5f;
			float num = ((Random.value < 0.5f) ? (-1f) : 1f);
			_ballVX = 0.45f * num;
			_ballVY = (Random.value * 0.3f + 0.2f) * ((Random.value < 0.5f) ? (-1f) : 1f);
		}

		private float Reflect01(float t)
		{
			t = Mathf.Abs(t) % 2f;
			return (t > 1f) ? (2f - t) : t;
		}

		private void StepPong(float dt)
		{
			float num = 0f;
			float num2 = 0f;
			if (Input.GetKey((KeyCode)119))
			{
				num += 0.7f * dt;
			}
			if (Input.GetKey((KeyCode)115))
			{
				num -= 0.7f * dt;
			}
			float num3 = Mathf.Clamp01((float)_pongLeftScore / 6f);
			float num4 = Mathf.Lerp(0.385f, 0.945f, num3);
			float num5 = Mathf.Lerp(0.35f, 0.05f, num3);
			float num6 = Mathf.Lerp(0.4f, 0.95f, num3);
			float num7 = Mathf.Lerp(0.08f, 0.35f, num3);
			float num8 = Mathf.Lerp(0.1f, 0.01f, num3);
			float paddleRightY = _paddleRightY;
			if (_ballVX > 0f)
			{
				float num9 = 0.94f - _ballX;
				float num10 = Mathf.Max(0f, num9 / Mathf.Max(0.001f, _ballVX));
				float num11 = num10 + num5;
				float t = _ballY + _ballVY * num11;
				t = Reflect01(t);
				paddleRightY = Mathf.Lerp(_paddleRightY, t, num6);
			}
			else
			{
				paddleRightY = Mathf.Lerp(_paddleRightY, 0.5f, num7);
			}
			paddleRightY += (Random.value - 0.5f) * num8;
			float num12 = Mathf.Clamp(paddleRightY - _paddleRightY, (0f - num4) * dt, num4 * dt);
			num2 += num12;
			_paddleLeftY = Mathf.Clamp01(_paddleLeftY + num);
			_paddleRightY = Mathf.Clamp01(_paddleRightY + num2);
			_ballX += _ballVX * dt;
			_ballY += _ballVY * dt;
			if (_ballY < 0.012f)
			{
				_ballY = 0.012f;
				_ballVY = Mathf.Abs(_ballVY);
			}
			if (_ballY > 0.988f)
			{
				_ballY = 0.988f;
				_ballVY = 0f - Mathf.Abs(_ballVY);
			}
			float num13 = 0.06f;
			float num14 = 0.94f;
			if (_ballVX < 0f && _ballX - 0.012f <= num13 + 0.015f && _ballX >= num13 && Mathf.Abs(_ballY - _paddleLeftY) <= 0.10800001f)
			{
				_ballX = num13 + 0.015f + 0.012f;
				_ballVX = Mathf.Abs(_ballVX) * 1.03f;
				float num15 = (_ballY - _paddleLeftY) / 0.10800001f;
				_ballVY = Mathf.Clamp(_ballVY + num15 * 0.35f, -0.8f, 0.8f);
				PlayHitSfx();
			}
			if (_ballVX > 0f && _ballX + 0.012f >= num14 && _ballX <= num14 + 0.015f && Mathf.Abs(_ballY - _paddleRightY) <= 0.10800001f)
			{
				_ballX = num14 - 0.012f;
				_ballVX = (0f - Mathf.Abs(_ballVX)) * 1.03f;
				float num16 = (_ballY - _paddleRightY) / 0.10800001f;
				_ballVY = Mathf.Clamp(_ballVY + num16 * 0.35f, -0.8f, 0.8f);
				PlayHitSfx();
			}
			if (_ballX < 0f)
			{
				_pongRightScore++;
				InitPong();
			}
			else if (_ballX > 1f)
			{
				_pongLeftScore++;
				InitPong();
			}
		}

		private void DrawPongTab()
		{
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Unknown result type (might be due to invalid IL or missing references)
			if (!_pongInit)
			{
				InitPong();
			}
			GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
			if (GUILayout.Button(_pongPaused ? "Resume" : "Pause", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(110f) }))
			{
				_pongPaused = !_pongPaused;
			}
			if (GUILayout.Button("Reset Round", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(130f) }))
			{
				InitPong();
				_pongPaused = false;
			}
			if (GUILayout.Button("Reset Score", _buttonStyle, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(130f) }))
			{
				_pongLeftScore = (_pongRightScore = 0);
				InitPong();
				_pongPaused = false;
			}
			GUILayout.FlexibleSpace();
			GUILayout.Label($"Score  <b>{_pongLeftScore}</b> : <b>{_pongRightScore}</b>", _labelHeaderStyle, Array.Empty<GUILayoutOption>());
			GUILayout.EndHorizontal();
			GUILayout.Space(8f);
			Rect rect = GUILayoutUtility.GetRect(GUIContent.none, GUI.skin.box, (GUILayoutOption[])(object)new GUILayoutOption[2]
			{
				GUILayout.ExpandWidth(true),
				GUILayout.Height(360f)
			});
			GUI.DrawTexture(new Rect(((Rect)(ref rect)).x + 6f, ((Rect)(ref rect)).y + 6f, ((Rect)(ref rect)).width, ((Rect)(ref rect)).height), (Texture)(object)_shadowSmall, (ScaleMode)0, true);
			GUI.DrawTexture(rect, (Texture)(object)_texGlassPanel, (ScaleMode)0, true);
			DrawRectBorder(new Rect(((Rect)(ref rect)).x + 2f, ((Rect)(ref rect)).y + 2f, ((Rect)(ref rect)).width - 4f, ((Rect)(ref rect)).height - 4f), 1f, (Texture)(object)_texBorder);
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(((Rect)(ref rect)).x + ((Rect)(ref rect)).width * 0.5f - 1f, ((Rect)(ref rect)).y + 4f, 2f, ((Rect)(ref rect)).height - 8f);
			GUI.DrawTexture(val, (Texture)(object)_texWhite);
			float x = ((Rect)(ref rect)).x;
			float y = ((Rect)(ref rect)).y;
			float width = ((Rect)(ref rect)).width;
			float height = ((Rect)(ref rect)).height;
			float num = 0.18f * height * 0.5f;
			float num2 = 0.015f * width;
			Rect val2 = default(Rect);
			((Rect)(ref val2))..ctor(x + width * 0.06f, y + _paddleLeftY * height - num, num2, num * 2f);
			Rect val3 = default(Rect);
			((Rect)(ref val3))..ctor(x + width * 0.94f, y + _paddleRightY * height - num, num2, num * 2f);
			GUI.DrawTexture(val2, (Texture)(object)_texWhite);
			GUI.DrawTexture(val3, (Texture)(object)_texWhite);
			float num3 = 0.012f * Mathf.Min(width, height);
			Rect val4 = default(Rect);
			((Rect)(ref val4))..ctor(x + _ballX * width - num3, y + _ballY * height - num3, num3 * 2f, num3 * 2f);
			GUI.DrawTexture(val4, (Texture)(object)_texWhite);
			GUILayout.Space(6f);
			GUILayout.Label("<i>Controls: Left = W/S, Right = Up/Down. Uses unscaled time; playable even when the game is paused.</i>", _thinLabelStyle, Array.Empty<GUILayoutOption>());
		}

		private void DrawCracktroOverlay(Rect winRect)
		{
			//IL_0065: 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_00a6: 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_00f8: 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_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Expected O, but got Unknown
			//IL_018d: 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_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Expected O, but got Unknown
			//IL_0234: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Expected O, but got Unknown
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02db: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Expected O, but got Unknown
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0302: Unknown result type (might be due to invalid IL or missing references)
			//IL_0324: Unknown result type (might be due to invalid IL or missing references)
			//IL_0330: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Unknown result type (might be due to invalid IL or missing references)
			//IL_034d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_037b: Unknown result type (might be due to invalid IL or missing references)
			//IL_038b: Unknown result type (might be due to invalid IL or missing references)
			//IL_039c: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: U