using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.SceneManagement;

[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: AssemblyCompany("Omniscye")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EmpressRPCVisualizer")]
[assembly: AssemblyTitle("EmpressRPCVisualizer")]
[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 Empress.RpcViz
{
	[BepInPlugin("Empress.RpcViz", "Empress_RpcViz", "1.1.0")]
	public class Empress_RpcViz : BaseUnityPlugin
	{
		internal class Visualizer
		{
			private class Dot
			{
				public GameObject go = null;

				public Vector3 from;

				public Vector3 to;

				public float t;

				public float travelTime;
			}

			private readonly Transform _root;

			private readonly List<Dot> _active = new List<Dot>(64);

			private readonly Stack<GameObject> _pool = new Stack<GameObject>();

			private const float Speed = 14f;

			private const float MinTime = 0.08f;

			private const float MaxTime = 0.8f;

			public int MaxActive { get; set; }

			public float Scale { get; set; }

			public Visualizer(Transform root, int maxActive, float scale)
			{
				_root = root;
				MaxActive = maxActive;
				Scale = scale;
			}

			public void Tick(float dt)
			{
				//IL_0069: 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_007a: Unknown result type (might be due to invalid IL or missing references)
				//IL_007f: Unknown result type (might be due to invalid IL or missing references)
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				for (int num = _active.Count - 1; num >= 0; num--)
				{
					Dot dot = _active[num];
					dot.t += dt / dot.travelTime;
					if (dot.t >= 1f)
					{
						Reclaim(dot.go);
						_active.RemoveAt(num);
					}
					else
					{
						Vector3 position = Vector3.LerpUnclamped(dot.from, dot.to, dot.t);
						dot.go.transform.position = position;
					}
				}
			}

			public void Shoot(Vector3 from, Vector3 to, Color color)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: 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)
				if (_active.Count < MaxActive)
				{
					GameObject val = Spawn(color);
					float num = Vector3.Distance(from, to);
					float travelTime = Mathf.Clamp(num / 14f, 0.08f, 0.8f);
					val.transform.position = from;
					_active.Add(new Dot
					{
						go = val,
						from = from,
						to = to,
						t = 0f,
						travelTime = travelTime
					});
				}
			}

			private GameObject Spawn(Color tint)
			{
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f2: Expected O, but got Unknown
				GameObject val;
				if (_pool.Count > 0)
				{
					val = _pool.Pop();
					if (Object.op_Implicit((Object)(object)val))
					{
						val.transform.localScale = Vector3.one * Scale;
						ApplyColor(val, tint);
					}
					return val;
				}
				val = GameObject.CreatePrimitive((PrimitiveType)0);
				((Object)val).hideFlags = (HideFlags)61;
				val.transform.SetParent(_root, false);
				val.transform.localScale = Vector3.one * Scale;
				Collider component = val.GetComponent<Collider>();
				if (Object.op_Implicit((Object)(object)component))
				{
					component.enabled = false;
				}
				MeshRenderer component2 = val.GetComponent<MeshRenderer>();
				if ((Object)(object)component2 != (Object)null)
				{
					Shader val2 = Shader.Find("Unlit/Color");
					if ((Object)(object)val2 != (Object)null)
					{
						((Renderer)component2).material = new Material(val2);
					}
					EnsureTransparent(((Renderer)component2).material);
				}
				ApplyColor(val, tint);
				return val;
			}

			private void ApplyColor(GameObject go, Color tint)
			{
				//IL_0031: 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_004a: 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_0086: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Unknown result type (might be due to invalid IL or missing references)
				MeshRenderer component = go.GetComponent<MeshRenderer>();
				if ((Object)(object)component == (Object)null)
				{
					return;
				}
				Material material = ((Renderer)component).material;
				if (!((Object)(object)material == (Object)null))
				{
					if (material.HasProperty("_BaseColor"))
					{
						material.SetColor("_BaseColor", tint);
					}
					if (material.HasProperty("_Color"))
					{
						material.SetColor("_Color", tint);
					}
					if (material.HasProperty("_AlbedoColor"))
					{
						material.SetColor("_AlbedoColor", tint);
					}
					if (material.HasProperty("_EmissionColor"))
					{
						Color val = default(Color);
						((Color)(ref val))..ctor(tint.r, tint.g, tint.b);
						material.SetColor("_EmissionColor", val);
						material.EnableKeyword("_EMISSION");
					}
					EnsureTransparent(material);
				}
			}

			private void EnsureTransparent(Material mat)
			{
				if (!((Object)(object)mat == (Object)null))
				{
					if (mat.HasProperty("_Surface"))
					{
						mat.SetFloat("_Surface", 1f);
					}
					if (mat.HasProperty("_Mode"))
					{
						mat.SetFloat("_Mode", 3f);
					}
					mat.SetInt("_SrcBlend", 5);
					mat.SetInt("_DstBlend", 10);
					mat.SetInt("_ZWrite", 0);
					mat.DisableKeyword("_ALPHATEST_ON");
					mat.EnableKeyword("_ALPHABLEND_ON");
					mat.DisableKeyword("_ALPHAPREMULTIPLY_ON");
					mat.renderQueue = 3000;
				}
			}

			private void Reclaim(GameObject go)
			{
				if (Object.op_Implicit((Object)(object)go))
				{
					_pool.Push(go);
				}
			}
		}

		private bool _subscribed;

		private static byte _rpcEventCode = byte.MaxValue;

		internal static Visualizer _viz;

		private ConfigEntry<bool> _enableInboundRPC = null;

		private ConfigEntry<bool> _enableOutboundRPC = null;

		private ConfigEntry<bool> _ignoreSelfInbound = null;

		private ConfigEntry<string> _rpcMethodAllow = null;

		private ConfigEntry<string> _rpcMethodBlock = null;

		private ConfigEntry<string> _allowedTargets = null;

		private ConfigEntry<float> _perActorMinInterval = null;

		private ConfigEntry<int> _maxActiveDots = null;

		private ConfigEntry<float> _dotScale = null;

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

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

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

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

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

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

		internal static Empress_RpcViz Instance { get; private set; } = null;


		internal static ManualLogSource Logger => Instance._logger;

		private ManualLogSource _logger => ((BaseUnityPlugin)this).Logger;

		internal Harmony? Harmony { get; set; }

		private void Awake()
		{
			Instance = this;
			((Component)this).gameObject.transform.parent = null;
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			_enableInboundRPC = ((BaseUnityPlugin)this).Config.Bind<bool>("Filter", "EnableInboundRPC", true, "");
			_enableOutboundRPC = ((BaseUnityPlugin)this).Config.Bind<bool>("Filter", "EnableOutboundRPC", true, "");
			_ignoreSelfInbound = ((BaseUnityPlugin)this).Config.Bind<bool>("Filter", "IgnoreSelfInbound", true, "");
			_rpcMethodAllow = ((BaseUnityPlugin)this).Config.Bind<string>("Filter", "RpcMethodAllowList", "", "");
			_rpcMethodBlock = ((BaseUnityPlugin)this).Config.Bind<string>("Filter", "RpcMethodBlockList", "", "");
			_allowedTargets = ((BaseUnityPlugin)this).Config.Bind<string>("Filter", "AllowedTargets", "All;AllBuffered;AllViaServer;AllBufferedViaServer;Others;OthersBuffered;MasterClient;Player", "");
			_perActorMinInterval = ((BaseUnityPlugin)this).Config.Bind<float>("Filter", "PerActorMinIntervalSeconds", 0.15f, "");
			_maxActiveDots = ((BaseUnityPlugin)this).Config.Bind<int>("Visual", "MaxActiveDots", 96, "");
			_dotScale = ((BaseUnityPlugin)this).Config.Bind<float>("Visual", "DotScale", 0.16f, "");
			RebuildTargetAllowlist();
			RebuildNameLists();
			_viz = new Visualizer(((Component)this).gameObject.transform, _maxActiveDots.Value, Mathf.Max(0.02f, _dotScale.Value));
			ResolveRpcEventCode();
			Patch();
			SceneManager.sceneLoaded += OnSceneLoaded;
			RetargetEventHook();
			Logger.LogInfo((object)$"{((BaseUnityPlugin)this).Info.Metadata.GUID} v{((BaseUnityPlugin)this).Info.Metadata.Version} loaded");
		}

		private void OnDestroy()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
			Unsubscribe();
			Harmony? harmony = Harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}

		private void OnSceneLoaded(Scene s, LoadSceneMode m)
		{
			RetargetEventHook();
			RebuildTargetAllowlist();
			RebuildNameLists();
		}

		private static bool IsGameplayScene()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string text = ((Scene)(ref activeScene)).name ?? string.Empty;
			if (string.IsNullOrEmpty(text))
			{
				return false;
			}
			if (text.IndexOf("Lobby", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			if (text.IndexOf("Menu", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			if (text.IndexOf("MainMenu", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			if (text.IndexOf("Title", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return false;
			}
			return true;
		}

		private void RetargetEventHook()
		{
			if (IsGameplayScene())
			{
				Subscribe();
			}
			else
			{
				Unsubscribe();
			}
		}

		private void Subscribe()
		{
			if (!_subscribed)
			{
				LoadBalancingClient networkingClient = PhotonNetwork.NetworkingClient;
				if (networkingClient != null)
				{
					networkingClient.EventReceived += OnEventReceived;
					_subscribed = true;
				}
			}
		}

		private void Unsubscribe()
		{
			if (_subscribed)
			{
				LoadBalancingClient networkingClient = PhotonNetwork.NetworkingClient;
				if (networkingClient != null)
				{
					networkingClient.EventReceived -= OnEventReceived;
				}
				_subscribed = false;
			}
		}

		private void Update()
		{
			if (_rpcEventCode == byte.MaxValue)
			{
				ResolveRpcEventCode();
			}
			if (!IsGameplayScene())
			{
				if (_subscribed)
				{
					Unsubscribe();
				}
			}
			else if (!_subscribed)
			{
				Subscribe();
			}
			if (_viz != null)
			{
				if (_viz.MaxActive != _maxActiveDots.Value)
				{
					_viz.MaxActive = _maxActiveDots.Value;
				}
				if (Mathf.Abs(_viz.Scale - _dotScale.Value) > 0.001f)
				{
					_viz.Scale = Mathf.Max(0.02f, _dotScale.Value);
				}
				_viz.Tick(Time.deltaTime);
			}
		}

		internal void Patch()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0026: Expected O, but got Unknown
			if (Harmony == null)
			{
				Harmony val = new Harmony(((BaseUnityPlugin)this).Info.Metadata.GUID);
				Harmony val2 = val;
				Harmony = val;
			}
			Harmony.PatchAll();
		}

		internal static bool Ready()
		{
			if (!PhotonNetwork.IsConnected)
			{
				return false;
			}
			if (!PhotonNetwork.InRoom)
			{
				return false;
			}
			if (SemiFunc.MenuLevel())
			{
				return false;
			}
			PlayerAvatar val = SemiFunc.PlayerAvatarLocal();
			if (!Object.op_Implicit((Object)(object)val))
			{
				return false;
			}
			return true;
		}

		private static void ResolveRpcEventCode()
		{
			try
			{
				Assembly assembly = typeof(PhotonNetwork).Assembly;
				Type type = assembly.GetType("Photon.Pun.PunEvent");
				if (type != null && type.IsEnum)
				{
					object value = Enum.Parse(type, "RPC");
					_rpcEventCode = Convert.ToByte(value);
					return;
				}
			}
			catch
			{
			}
			_rpcEventCode = 200;
		}

		private void OnEventReceived(EventData photonEvent)
		{
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			if (!Ready())
			{
				return;
			}
			byte code = photonEvent.Code;
			if ((code != _rpcEventCode && code != 200) || !_enableInboundRPC.Value)
			{
				return;
			}
			int sender = photonEvent.Sender;
			if ((_ignoreSelfInbound.Value && PhotonNetwork.LocalPlayer != null && sender == PhotonNetwork.LocalPlayer.ActorNumber) || !PassThrottle(_lastInbound, sender, _perActorMinInterval.Value))
			{
				return;
			}
			Room currentRoom = PhotonNetwork.CurrentRoom;
			Player val = ((currentRoom != null) ? currentRoom.GetPlayer(sender, false) : null);
			if (val != null)
			{
				PlayerAvatar val2 = AvatarFromPlayer(val);
				PlayerAvatar val3 = SemiFunc.PlayerAvatarLocal();
				if (Object.op_Implicit((Object)(object)val2) && Object.op_Implicit((Object)(object)val3))
				{
					Color color = TryGetAvatarColor(val2, Color.yellow, 0.35f);
					_viz.Shoot(AvatarPos(val2), AvatarPos(val3), color);
				}
			}
		}

		internal static PlayerAvatar AvatarFromPlayer(Player p)
		{
			if (p == null)
			{
				return null;
			}
			PlayerAvatar val = AvatarFromActorNumber(p.ActorNumber);
			if (Object.op_Implicit((Object)(object)val))
			{
				return val;
			}
			string userId = p.UserId;
			if (string.IsNullOrEmpty(userId))
			{
				return null;
			}
			return SemiFunc.PlayerGetFromSteamID(userId);
		}

		internal static PlayerAvatar AvatarFromActorNumber(int actorNumber)
		{
			if (actorNumber <= 0)
			{
				return null;
			}
			PlayerAvatar[] array = Object.FindObjectsOfType<PlayerAvatar>(true);
			foreach (PlayerAvatar val in array)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				PhotonView photonView = val.photonView;
				if (!Object.op_Implicit((Object)(object)photonView))
				{
					continue;
				}
				try
				{
					if (photonView.OwnerActorNr == actorNumber)
					{
						return val;
					}
				}
				catch
				{
				}
			}
			return null;
		}

		internal static Vector3 AvatarPos(PlayerAvatar av)
		{
			//IL_000e: 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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)av))
			{
				return Vector3.zero;
			}
			Transform val = (Object.op_Implicit((Object)(object)av.playerTransform) ? av.playerTransform : ((Component)av).transform);
			return val.position + Vector3.up * 1.6f;
		}

		private static bool PassThrottle(Dictionary<int, float> map, int key, float minInterval)
		{
			if (minInterval <= 0f)
			{
				return true;
			}
			float time = Time.time;
			if (map.TryGetValue(key, out var value))
			{
				if (time - value < minInterval)
				{
					return false;
				}
				map[key] = time;
				return true;
			}
			map[key] = time;
			return true;
		}

		private static string[] SplitList(string s)
		{
			if (string.IsNullOrWhiteSpace(s))
			{
				return Array.Empty<string>();
			}
			string[] array = s.Split(new char[3] { ';', ',', '|' }, StringSplitOptions.RemoveEmptyEntries);
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = array[i].Trim();
			}
			return array;
		}

		private void RebuildTargetAllowlist()
		{
			_allowedTargetSet.Clear();
			string[] array = SplitList(_allowedTargets.Value);
			for (int i = 0; i < array.Length; i++)
			{
				_allowedTargetSet.Add(array[i]);
			}
		}

		private void RebuildNameLists()
		{
			_allowNames = SplitList(_rpcMethodAllow.Value);
			_blockNames = SplitList(_rpcMethodBlock.Value);
		}

		internal static Color TryGetAvatarColor(PlayerAvatar av, Color fallback, float alpha)
		{
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_00c5: 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)
			try
			{
				if (Object.op_Implicit((Object)(object)av) && Object.op_Implicit((Object)(object)av.playerAvatarVisuals) && Object.op_Implicit((Object)(object)av.playerAvatarVisuals.meshParent))
				{
					Renderer componentInChildren = av.playerAvatarVisuals.meshParent.GetComponentInChildren<Renderer>(true);
					if (Object.op_Implicit((Object)(object)componentInChildren) && Object.op_Implicit((Object)(object)componentInChildren.sharedMaterial))
					{
						if (componentInChildren.sharedMaterial.HasProperty("_AlbedoColor"))
						{
							Color color = componentInChildren.sharedMaterial.GetColor("_AlbedoColor");
							color.a = alpha;
							return color;
						}
						if (componentInChildren.sharedMaterial.HasProperty("_Color"))
						{
							Color color2 = componentInChildren.sharedMaterial.GetColor("_Color");
							color2.a = alpha;
							return color2;
						}
					}
				}
			}
			catch
			{
			}
			fallback.a = alpha;
			return fallback;
		}

		internal static bool MethodPasses(string methodName)
		{
			string[] allowNames = Instance._allowNames;
			string[] blockNames = Instance._blockNames;
			if (blockNames != null && blockNames.Length != 0)
			{
				for (int i = 0; i < blockNames.Length; i++)
				{
					if (!string.IsNullOrEmpty(blockNames[i]) && methodName.IndexOf(blockNames[i], StringComparison.OrdinalIgnoreCase) >= 0)
					{
						return false;
					}
				}
			}
			if (allowNames != null && allowNames.Length != 0)
			{
				bool flag = false;
				for (int j = 0; j < allowNames.Length; j++)
				{
					if (!string.IsNullOrEmpty(allowNames[j]) && methodName.IndexOf(allowNames[j], StringComparison.OrdinalIgnoreCase) >= 0)
					{
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					return false;
				}
			}
			return true;
		}

		internal static bool TargetPasses(string key)
		{
			return Instance._allowedTargetSet.Count == 0 || Instance._allowedTargetSet.Contains(key);
		}

		internal static bool OutboundEnabled()
		{
			return Instance._enableOutboundRPC.Value;
		}

		internal static bool OutboundThrottlePass(int actorNumber)
		{
			return PassThrottle(Instance._lastOutbound, actorNumber, Instance._perActorMinInterval.Value);
		}
	}
	[HarmonyPatch(typeof(PhotonView), "RPC", new Type[]
	{
		typeof(string),
		typeof(RpcTarget),
		typeof(object[])
	})]
	public static class Patch_PhotonView_RPC_RpcTarget
	{
		public static void Postfix(PhotonView __instance, string methodName, RpcTarget target, object[] parameters)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: 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_0115: Unknown result type (might be due to invalid IL or missing references)
			if (!Empress_RpcViz.Ready() || !Empress_RpcViz.OutboundEnabled() || !Empress_RpcViz.MethodPasses(methodName))
			{
				return;
			}
			string key = ((object)(RpcTarget)(ref target)).ToString();
			if (!Empress_RpcViz.TargetPasses(key))
			{
				return;
			}
			PlayerAvatar val = SemiFunc.PlayerAvatarLocal();
			if (!Object.op_Implicit((Object)(object)val))
			{
				return;
			}
			Color color = Empress_RpcViz.TryGetAvatarColor(val, Color.yellow, 0.35f);
			IEnumerable<Player> enumerable = ResolveTargets(target);
			if (enumerable == null)
			{
				return;
			}
			foreach (Player item in enumerable)
			{
				if (item != null && item != PhotonNetwork.LocalPlayer && Empress_RpcViz.OutboundThrottlePass(item.ActorNumber))
				{
					PlayerAvatar val2 = Empress_RpcViz.AvatarFromPlayer(item);
					if (Object.op_Implicit((Object)(object)val2))
					{
						Empress_RpcViz._viz.Shoot(Empress_RpcViz.AvatarPos(val), Empress_RpcViz.AvatarPos(val2), color);
					}
				}
			}
		}

		private static IEnumerable<Player> ResolveTargets(RpcTarget t)
		{
			//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_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected I4, but got Unknown
			switch ((int)t)
			{
			case 0:
			case 3:
			case 5:
			case 6:
				return PhotonNetwork.PlayerList;
			case 1:
			case 4:
				return PhotonNetwork.PlayerListOthers;
			case 2:
				return (IEnumerable<Player>)(object)new Player[1] { PhotonNetwork.MasterClient };
			default:
				return null;
			}
		}
	}
	[HarmonyPatch(typeof(PhotonView), "RPC", new Type[]
	{
		typeof(string),
		typeof(Player),
		typeof(object[])
	})]
	public static class Patch_PhotonView_RPC_Player
	{
		public static void Postfix(PhotonView __instance, string methodName, Player targetPlayer, object[] parameters)
		{
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if (!Empress_RpcViz.Ready() || !Empress_RpcViz.OutboundEnabled() || !Empress_RpcViz.MethodPasses(methodName) || !Empress_RpcViz.TargetPasses("Player"))
			{
				return;
			}
			PlayerAvatar val = SemiFunc.PlayerAvatarLocal();
			if (Object.op_Implicit((Object)(object)val) && targetPlayer != null && targetPlayer != PhotonNetwork.LocalPlayer && Empress_RpcViz.OutboundThrottlePass(targetPlayer.ActorNumber))
			{
				PlayerAvatar val2 = Empress_RpcViz.AvatarFromPlayer(targetPlayer);
				if (Object.op_Implicit((Object)(object)val2))
				{
					Color color = Empress_RpcViz.TryGetAvatarColor(val, Color.yellow, 0.35f);
					Empress_RpcViz._viz.Shoot(Empress_RpcViz.AvatarPos(val), Empress_RpcViz.AvatarPos(val2), color);
				}
			}
		}
	}
}