Decompiled source of Crowbar v1.0.6

Crowbar.dll

Decompiled 4 days ago
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using Crowbar;
using HarmonyLib;
using Il2Cpp;
using Il2CppHUD;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppPhoton.Client;
using Il2CppPhoton.Deterministic;
using Il2CppPhoton.Realtime;
using Il2CppQuantum;
using Il2CppQuantum.Core;
using Il2CppQuantum_Core;
using Il2CppSystem;
using Il2CppSystem.Collections;
using Il2CppSystem.Collections.Generic;
using Il2CppView_Humanoid;
using MelonLoader;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(Core), "Crowbar", "1.0.6", "Klehrik", null)]
[assembly: MelonGame("Videocult", "Airframe")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("Klehrik")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.6.0")]
[assembly: AssemblyInformationalVersion("1.0.0+af8127c4396a95bf8d48c06a50ca501d0bcff8e0")]
[assembly: AssemblyProduct("Crowbar")]
[assembly: AssemblyTitle("Crowbar")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace Crowbar
{
	public static class ActionMenu
	{
		public class Option
		{
			private static int idCounter = 10000;

			internal static readonly Dictionary<int, Action> callbacks = new Dictionary<int, Action>();

			public int ID { get; }

			public string Label { get; set; }

			public Option(Action callback, string label)
			{
				ID = idCounter++;
				Label = label;
				callbacks[ID] = callback;
			}

			public Option(Action callback)
				: this(callback, "unknown")
			{
			}
		}

		[HarmonyPatch(typeof(Actions))]
		public static class RadialMenu_Component_ActionsPatch
		{
			[HarmonyPostfix]
			[HarmonyPatch("RefreshItems")]
			private static void RefreshItemsPostfix(Actions __instance)
			{
				instance = __instance;
				CollectOptions();
			}

			[HarmonyPostfix]
			[HarmonyPatch("GetOptionName")]
			private static void GetOptionNamePostfix(Actions __instance, ref string __result, ref int index)
			{
				if (indexToLabel.TryGetValue(index, out var value))
				{
					__result = value;
				}
			}
		}

		[HarmonyPatch(typeof(RadialMenu_Component))]
		public static class RadialMenu_ComponentPatch
		{
			[HarmonyPostfix]
			[HarmonyPatch("HandleSelection")]
			private static void HandleSelectionPostfix(RadialMenu_Component __instance, ref int selectedItemIndex, ref int selectedItemValue)
			{
				if (Option.callbacks.ContainsKey(selectedItemValue))
				{
					Option.callbacks[selectedItemValue]();
					selectedItemIndex = -1;
					selectedItemValue = -1;
				}
			}
		}

		private static readonly List<Action> callbacks = new List<Action>();

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

		private static int currentIndex = 0;

		private static bool collecting = false;

		private static Actions instance;

		public static void RegisterForCollection(Action callback)
		{
			callbacks.Add(callback);
		}

		public static void AddOption(Option option, string label, bool selectable = true)
		{
			if (!collecting)
			{
				throw new InvalidOperationException("Cannot add options outside of collection time.");
			}
			((SpecificRadial)instance).AddItem(option.ID, !selectable);
			indexToLabel[currentIndex++] = label;
		}

		public static void AddOption(Option option, bool selectable = true)
		{
			AddOption(option, option.Label, selectable);
		}

		private static void CollectOptions()
		{
			currentIndex = ((SpecificRadial)instance).items.Count;
			collecting = true;
			foreach (Action callback in callbacks)
			{
				callback();
			}
			collecting = false;
		}
	}
	public class Command
	{
		[HarmonyPatch(typeof(SpecialActionCommand), "Execute")]
		public static class SpecialActionCommandPatch
		{
			private static bool Prefix(SpecialActionCommand __instance, Frame f)
			{
				int action = __instance.action;
				if (idToIdentifier.ContainsKey(action))
				{
					string key = idToIdentifier[action];
					if (callbacks.ContainsKey(key))
					{
						callbacks[key](f);
						return false;
					}
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(PlayerJoinSystem), "OnPlayerAdded")]
		public static class PlayerJoinSystemPatch
		{
			private static void Postfix(PlayerJoinSystem __instance)
			{
				if (!Misc.IsHost())
				{
					return;
				}
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				foreach (KeyValuePair<string, int> item in identifierToId)
				{
					dictionary.Add(item.Key, item.Value.ToString());
				}
				packet.Send(dictionary);
			}
		}

		private static int idCounter;

		private static readonly Dictionary<int, string> idToIdentifier;

		private static readonly Dictionary<string, int> identifierToId;

		private static readonly Dictionary<string, Action<Frame>> callbacks;

		private static Packet packet;

		public string Identifier { get; }

		static Command()
		{
			idCounter = 20000;
			idToIdentifier = new Dictionary<int, string>();
			identifierToId = new Dictionary<string, int>();
			callbacks = new Dictionary<string, Action<Frame>>();
			packet = new Packet("Crowbar_Command", delegate(Player player, Dictionary<string, string> data)
			{
				StringBuilder stringBuilder = new StringBuilder("Incoming host command mappings:");
				foreach (KeyValuePair<string, string> datum in data)
				{
					string key = datum.Key;
					int num = int.Parse(datum.Value);
					stringBuilder.Append("\n" + num + ": " + key);
					idCounter = Math.Max(idCounter, num + 1);
					if (idToIdentifier.ContainsKey(num))
					{
						string text = idToIdentifier[num];
						if (text != key)
						{
							int num2 = idCounter++;
							if (!data.ContainsKey(text))
							{
								idToIdentifier[num2] = text;
								identifierToId[text] = num2;
							}
						}
					}
					idToIdentifier[num] = key;
					identifierToId[key] = num;
				}
				Core.Logger.Msg((object)stringBuilder);
			});
		}

		public Command(string identifier, Action<Frame> callback)
		{
			if (callbacks.ContainsKey(identifier))
			{
				throw new ArgumentException("Identifier '" + identifier + "' is already in use.");
			}
			Identifier = identifier;
			callbacks[Identifier] = callback;
			int num = idCounter++;
			idToIdentifier[num] = identifier;
			identifierToId[identifier] = num;
		}

		public bool Send(out string error)
		{
			//IL_0068: 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_0084: 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_0092: Expected O, but got Unknown
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			QuantumRunner obj = QuantumRunner.Default;
			QuantumGame val = ((obj != null) ? obj.Game : null);
			if (val == null)
			{
				error = "Command '" + Identifier + "': 'QuantumRunner.Default.Game' is null";
				return false;
			}
			Humanoid_View localHumanoidView = Misc.GetLocalHumanoidView();
			if ((Object)(object)localHumanoidView == (Object)null)
			{
				error = "Command '" + Identifier + "': Cannot find local Humanoid_View";
				return false;
			}
			SpecialActionCommand val2 = new SpecialActionCommand
			{
				action = identifierToId[Identifier],
				player = localHumanoidView.playerEntityRef
			};
			val.SendCommand((DeterministicCommand)(object)val2);
			error = "";
			return true;
		}

		public bool Send()
		{
			string error;
			return Send(out error);
		}
	}
	public class Core : MelonMod
	{
		internal static Instance Logger => Melon<Core>.Logger;
	}
	public static class Misc
	{
		private static Humanoid_View localHumanoidView;

		public static Humanoid_View GetLocalHumanoidView()
		{
			if ((Object)(object)localHumanoidView != (Object)null)
			{
				return localHumanoidView;
			}
			Il2CppArrayBase<Humanoid_View> val = Object.FindObjectsByType<Humanoid_View>((FindObjectsSortMode)0);
			foreach (Humanoid_View item in val)
			{
				if (item.isLocal)
				{
					localHumanoidView = item;
					return item;
				}
			}
			return null;
		}

		public static bool IsHost()
		{
			PhotonController instance = PhotonController.instance;
			return instance.IsMasterClient();
		}

		public static void PrintComponentList(EntityRef r)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: 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_01ac: 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_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_033c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: 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_0387: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0404: Unknown result type (might be due to invalid IL or missing references)
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0436: Unknown result type (might be due to invalid IL or missing references)
			//IL_044f: 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_0481: Unknown result type (might be due to invalid IL or missing references)
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0517: Unknown result type (might be due to invalid IL or missing references)
			//IL_0530: Unknown result type (might be due to invalid IL or missing references)
			//IL_0549: Unknown result type (might be due to invalid IL or missing references)
			//IL_0562: Unknown result type (might be due to invalid IL or missing references)
			//IL_057b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0594: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05df: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0611: Unknown result type (might be due to invalid IL or missing references)
			//IL_062a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0643: Unknown result type (might be due to invalid IL or missing references)
			//IL_065c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0675: 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_06a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_070b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0724: Unknown result type (might be due to invalid IL or missing references)
			//IL_073d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0756: Unknown result type (might be due to invalid IL or missing references)
			//IL_076f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0788: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0805: Unknown result type (might be due to invalid IL or missing references)
			//IL_081e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0837: Unknown result type (might be due to invalid IL or missing references)
			//IL_0850: Unknown result type (might be due to invalid IL or missing references)
			//IL_0869: Unknown result type (might be due to invalid IL or missing references)
			//IL_0882: Unknown result type (might be due to invalid IL or missing references)
			//IL_089b: Unknown result type (might be due to invalid IL or missing references)
			//IL_08b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_08cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0918: Unknown result type (might be due to invalid IL or missing references)
			//IL_0931: Unknown result type (might be due to invalid IL or missing references)
			//IL_094a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0963: Unknown result type (might be due to invalid IL or missing references)
			//IL_097c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0995: Unknown result type (might be due to invalid IL or missing references)
			//IL_09ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_09c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_09f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a12: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a2b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a44: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a5d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a76: Unknown result type (might be due to invalid IL or missing references)
			//IL_0a8f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0aa8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ac1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ada: Unknown result type (might be due to invalid IL or missing references)
			//IL_0af3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b0c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b25: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b3e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b57: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b70: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b89: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ba2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bbb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bd4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0bed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c06: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c1f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c38: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c51: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c6a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c83: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c9c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cb5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0cce: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ce7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d00: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d19: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d32: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d4b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d64: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d7d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0d96: Unknown result type (might be due to invalid IL or missing references)
			//IL_0daf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dc8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0de1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dfa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e13: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e2c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e45: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e5e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e77: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e90: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ea9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ec2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0edb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ef4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f0d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f26: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f3f: Unknown result type (might be due to invalid IL or missing references)
			QuantumRunner obj = QuantumRunner.Default;
			QuantumGame val = ((obj != null) ? obj.Game : null);
			if (val != null)
			{
				Frame verified = val.Frames.Verified;
				StringBuilder stringBuilder = new StringBuilder($"\nEntity '{r}' components:\n");
				if (((FrameBase)verified).Has<Transform2D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Transform2D\n");
				}
				if (((FrameBase)verified).Has<Transform3D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Transform3D\n");
				}
				if (((FrameBase)verified).Has<Transform2DVertical>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Transform2DVertical\n");
				}
				if (((FrameBase)verified).Has<PhysicsCollider2D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PhysicsCollider2D\n");
				}
				if (((FrameBase)verified).Has<PhysicsBody2D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PhysicsBody2D\n");
				}
				if (((FrameBase)verified).Has<PhysicsCollider3D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PhysicsCollider3D\n");
				}
				if (((FrameBase)verified).Has<PhysicsBody3D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PhysicsBody3D\n");
				}
				if (((FrameBase)verified).Has<PhysicsJoints2D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PhysicsJoints2D\n");
				}
				if (((FrameBase)verified).Has<PhysicsJoints3D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PhysicsJoints3D\n");
				}
				if (((FrameBase)verified).Has<PhysicsCallbacks2D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PhysicsCallbacks2D\n");
				}
				if (((FrameBase)verified).Has<PhysicsCallbacks3D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PhysicsCallbacks3D\n");
				}
				if (((FrameBase)verified).Has<CharacterController2D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.CharacterController2D\n");
				}
				if (((FrameBase)verified).Has<CharacterController3D>(r))
				{
					stringBuilder.Append("Il2CppQuantum.CharacterController3D\n");
				}
				if (((FrameBase)verified).Has<NavMeshPathfinder>(r))
				{
					stringBuilder.Append("Il2CppQuantum.NavMeshPathfinder\n");
				}
				if (((FrameBase)verified).Has<NavMeshSteeringAgent>(r))
				{
					stringBuilder.Append("Il2CppQuantum.NavMeshSteeringAgent\n");
				}
				if (((FrameBase)verified).Has<NavMeshAvoidanceAgent>(r))
				{
					stringBuilder.Append("Il2CppQuantum.NavMeshAvoidanceAgent\n");
				}
				if (((FrameBase)verified).Has<NavMeshAvoidanceObstacle>(r))
				{
					stringBuilder.Append("Il2CppQuantum.NavMeshAvoidanceObstacle\n");
				}
				if (((FrameBase)verified).Has<View>(r))
				{
					stringBuilder.Append("Il2CppQuantum.View\n");
				}
				if (((FrameBase)verified).Has<MapEntityLink>(r))
				{
					stringBuilder.Append("Il2CppQuantum.MapEntityLink\n");
				}
				if (((FrameBase)verified).Has<AffectedByRain>(r))
				{
					stringBuilder.Append("Il2CppQuantum.AffectedByRain\n");
				}
				if (((FrameBase)verified).Has<Airplane>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Airplane\n");
				}
				if (((FrameBase)verified).Has<AirplaneTraffic>(r))
				{
					stringBuilder.Append("Il2CppQuantum.AirplaneTraffic\n");
				}
				if (((FrameBase)verified).Has<Ammo>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Ammo\n");
				}
				if (((FrameBase)verified).Has<AntiYeetWorkaround>(r))
				{
					stringBuilder.Append("Il2CppQuantum.AntiYeetWorkaround\n");
				}
				if (((FrameBase)verified).Has<Armor>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Armor\n");
				}
				if (((FrameBase)verified).Has<AutoAim>(r))
				{
					stringBuilder.Append("Il2CppQuantum.AutoAim\n");
				}
				if (((FrameBase)verified).Has<AutoAimTarget>(r))
				{
					stringBuilder.Append("Il2CppQuantum.AutoAimTarget\n");
				}
				if (((FrameBase)verified).Has<AutoResetButton>(r))
				{
					stringBuilder.Append("Il2CppQuantum.AutoResetButton\n");
				}
				if (((FrameBase)verified).Has<AutoTurret>(r))
				{
					stringBuilder.Append("Il2CppQuantum.AutoTurret\n");
				}
				if (((FrameBase)verified).Has<AwayCircuitPlayers>(r))
				{
					stringBuilder.Append("Il2CppQuantum.AwayCircuitPlayers\n");
				}
				if (((FrameBase)verified).Has<Axe>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Axe\n");
				}
				if (((FrameBase)verified).Has<Bat>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Bat\n");
				}
				if (((FrameBase)verified).Has<BigScreen>(r))
				{
					stringBuilder.Append("Il2CppQuantum.BigScreen\n");
				}
				if (((FrameBase)verified).Has<BigScreen_PongGame>(r))
				{
					stringBuilder.Append("Il2CppQuantum.BigScreen_PongGame\n");
				}
				if (((FrameBase)verified).Has<BigScreen_Vote>(r))
				{
					stringBuilder.Append("Il2CppQuantum.BigScreen_Vote\n");
				}
				if (((FrameBase)verified).Has<BlockFlag>(r))
				{
					stringBuilder.Append("Il2CppQuantum.BlockFlag\n");
				}
				if (((FrameBase)verified).Has<BoxingBagBase>(r))
				{
					stringBuilder.Append("Il2CppQuantum.BoxingBagBase\n");
				}
				if (((FrameBase)verified).Has<Caltrops>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Caltrops\n");
				}
				if (((FrameBase)verified).Has<Car>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Car\n");
				}
				if (((FrameBase)verified).Has<CarLODMinusOne>(r))
				{
					stringBuilder.Append("Il2CppQuantum.CarLODMinusOne\n");
				}
				if (((FrameBase)verified).Has<Chain>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Chain\n");
				}
				if (((FrameBase)verified).Has<Chainsaw>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Chainsaw\n");
				}
				if (((FrameBase)verified).Has<CheckPoint>(r))
				{
					stringBuilder.Append("Il2CppQuantum.CheckPoint\n");
				}
				if (((FrameBase)verified).Has<CheckpointSpawner>(r))
				{
					stringBuilder.Append("Il2CppQuantum.CheckpointSpawner\n");
				}
				if (((FrameBase)verified).Has<ChromeLocker>(r))
				{
					stringBuilder.Append("Il2CppQuantum.ChromeLocker\n");
				}
				if (((FrameBase)verified).Has<Collectable>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Collectable\n");
				}
				if (((FrameBase)verified).Has<CollectablePickupPending>(r))
				{
					stringBuilder.Append("Il2CppQuantum.CollectablePickupPending\n");
				}
				if (((FrameBase)verified).Has<CollectableShop>(r))
				{
					stringBuilder.Append("Il2CppQuantum.CollectableShop\n");
				}
				if (((FrameBase)verified).Has<CollectableShopPickup>(r))
				{
					stringBuilder.Append("Il2CppQuantum.CollectableShopPickup\n");
				}
				if (((FrameBase)verified).Has<ConfettiCannon_Stationary>(r))
				{
					stringBuilder.Append("Il2CppQuantum.ConfettiCannon_Stationary\n");
				}
				if (((FrameBase)verified).Has<ConfettiGun>(r))
				{
					stringBuilder.Append("Il2CppQuantum.ConfettiGun\n");
				}
				if (((FrameBase)verified).Has<ConsumablesRespawner>(r))
				{
					stringBuilder.Append("Il2CppQuantum.ConsumablesRespawner\n");
				}
				if (((FrameBase)verified).Has<Controllable>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Controllable\n");
				}
				if (((FrameBase)verified).Has<ConveyorBelt>(r))
				{
					stringBuilder.Append("Il2CppQuantum.ConveyorBelt\n");
				}
				if (((FrameBase)verified).Has<ConveyorBeltTempMovingTerrain>(r))
				{
					stringBuilder.Append("Il2CppQuantum.ConveyorBeltTempMovingTerrain\n");
				}
				if (((FrameBase)verified).Has<Crowbar>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Crowbar\n");
				}
				if (((FrameBase)verified).Has<DependencyDespawn>(r))
				{
					stringBuilder.Append("Il2CppQuantum.DependencyDespawn\n");
				}
				if (((FrameBase)verified).Has<Despawn>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Despawn\n");
				}
				if (((FrameBase)verified).Has<Door>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Door\n");
				}
				if (((FrameBase)verified).Has<EMPgrenade>(r))
				{
					stringBuilder.Append("Il2CppQuantum.EMPgrenade\n");
				}
				if (((FrameBase)verified).Has<Electrocuted>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Electrocuted\n");
				}
				if (((FrameBase)verified).Has<EnterShopMessageTracker>(r))
				{
					stringBuilder.Append("Il2CppQuantum.EnterShopMessageTracker\n");
				}
				if (((FrameBase)verified).Has<EntityProjectile>(r))
				{
					stringBuilder.Append("Il2CppQuantum.EntityProjectile\n");
				}
				if (((FrameBase)verified).Has<Equipment>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Equipment\n");
				}
				if (((FrameBase)verified).Has<Explosion>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Explosion\n");
				}
				if (((FrameBase)verified).Has<Fire>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Fire\n");
				}
				if (((FrameBase)verified).Has<FloatOnOcean>(r))
				{
					stringBuilder.Append("Il2CppQuantum.FloatOnOcean\n");
				}
				if (((FrameBase)verified).Has<FoamBlob>(r))
				{
					stringBuilder.Append("Il2CppQuantum.FoamBlob\n");
				}
				if (((FrameBase)verified).Has<FreeMovingPickup>(r))
				{
					stringBuilder.Append("Il2CppQuantum.FreeMovingPickup\n");
				}
				if (((FrameBase)verified).Has<Grenade>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Grenade\n");
				}
				if (((FrameBase)verified).Has<Gun>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Gun\n");
				}
				if (((FrameBase)verified).Has<HangGlider>(r))
				{
					stringBuilder.Append("Il2CppQuantum.HangGlider\n");
				}
				if (((FrameBase)verified).Has<Healing>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Healing\n");
				}
				if (((FrameBase)verified).Has<Health>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Health\n");
				}
				if (((FrameBase)verified).Has<HeldByHumanoid>(r))
				{
					stringBuilder.Append("Il2CppQuantum.HeldByHumanoid\n");
				}
				if (((FrameBase)verified).Has<HeldByPickup>(r))
				{
					stringBuilder.Append("Il2CppQuantum.HeldByPickup\n");
				}
				if (((FrameBase)verified).Has<Horses>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Horses\n");
				}
				if (((FrameBase)verified).Has<HoverBike>(r))
				{
					stringBuilder.Append("Il2CppQuantum.HoverBike\n");
				}
				if (((FrameBase)verified).Has<Humanoid>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Humanoid\n");
				}
				if (((FrameBase)verified).Has<HumanoidOnMovingTerrain>(r))
				{
					stringBuilder.Append("Il2CppQuantum.HumanoidOnMovingTerrain\n");
				}
				if (((FrameBase)verified).Has<InventoryStashSafe>(r))
				{
					stringBuilder.Append("Il2CppQuantum.InventoryStashSafe\n");
				}
				if (((FrameBase)verified).Has<Jerrycan>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Jerrycan\n");
				}
				if (((FrameBase)verified).Has<Kalashnikov>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Kalashnikov\n");
				}
				if (((FrameBase)verified).Has<KillerTagTracker>(r))
				{
					stringBuilder.Append("Il2CppQuantum.KillerTagTracker\n");
				}
				if (((FrameBase)verified).Has<Laser>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Laser\n");
				}
				if (((FrameBase)verified).Has<Machete>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Machete\n");
				}
				if (((FrameBase)verified).Has<MeleeAttack>(r))
				{
					stringBuilder.Append("Il2CppQuantum.MeleeAttack\n");
				}
				if (((FrameBase)verified).Has<Minigun>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Minigun\n");
				}
				if (((FrameBase)verified).Has<MoneyFountain>(r))
				{
					stringBuilder.Append("Il2CppQuantum.MoneyFountain\n");
				}
				if (((FrameBase)verified).Has<MovingHazard>(r))
				{
					stringBuilder.Append("Il2CppQuantum.MovingHazard\n");
				}
				if (((FrameBase)verified).Has<MovingTerrain>(r))
				{
					stringBuilder.Append("Il2CppQuantum.MovingTerrain\n");
				}
				if (((FrameBase)verified).Has<ParticipatingPlayer>(r))
				{
					stringBuilder.Append("Il2CppQuantum.ParticipatingPlayer\n");
				}
				if (((FrameBase)verified).Has<PathBlocker>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PathBlocker\n");
				}
				if (((FrameBase)verified).Has<Pickup>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Pickup\n");
				}
				if (((FrameBase)verified).Has<PickupLockedForEntity>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PickupLockedForEntity\n");
				}
				if (((FrameBase)verified).Has<PillsAddiction>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PillsAddiction\n");
				}
				if (((FrameBase)verified).Has<Pipe>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Pipe\n");
				}
				if (((FrameBase)verified).Has<PlasmaBall>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PlasmaBall\n");
				}
				if (((FrameBase)verified).Has<PlasmaBall_Erratic>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PlasmaBall_Erratic\n");
				}
				if (((FrameBase)verified).Has<PlasmaGun>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PlasmaGun\n");
				}
				if (((FrameBase)verified).Has<PlayArea>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PlayArea\n");
				}
				if (((FrameBase)verified).Has<Player>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Player\n");
				}
				if (((FrameBase)verified).Has<PoliceCoordinator>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PoliceCoordinator\n");
				}
				if (((FrameBase)verified).Has<PoliceHelicopter>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PoliceHelicopter\n");
				}
				if (((FrameBase)verified).Has<PoliceVehicleGunman>(r))
				{
					stringBuilder.Append("Il2CppQuantum.PoliceVehicleGunman\n");
				}
				if (((FrameBase)verified).Has<QuickStrike>(r))
				{
					stringBuilder.Append("Il2CppQuantum.QuickStrike\n");
				}
				if (((FrameBase)verified).Has<RaceGameState>(r))
				{
					stringBuilder.Append("Il2CppQuantum.RaceGameState\n");
				}
				if (((FrameBase)verified).Has<RaceParticipator>(r))
				{
					stringBuilder.Append("Il2CppQuantum.RaceParticipator\n");
				}
				if (((FrameBase)verified).Has<RainStorm>(r))
				{
					stringBuilder.Append("Il2CppQuantum.RainStorm\n");
				}
				if (((FrameBase)verified).Has<Rebar>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Rebar\n");
				}
				if (((FrameBase)verified).Has<RebarGun>(r))
				{
					stringBuilder.Append("Il2CppQuantum.RebarGun\n");
				}
				if (((FrameBase)verified).Has<RetainOwnershipOnRespawn>(r))
				{
					stringBuilder.Append("Il2CppQuantum.RetainOwnershipOnRespawn\n");
				}
				if (((FrameBase)verified).Has<RiotShield>(r))
				{
					stringBuilder.Append("Il2CppQuantum.RiotShield\n");
				}
				if (((FrameBase)verified).Has<RiotStick>(r))
				{
					stringBuilder.Append("Il2CppQuantum.RiotStick\n");
				}
				if (((FrameBase)verified).Has<SandboxRespawn>(r))
				{
					stringBuilder.Append("Il2CppQuantum.SandboxRespawn\n");
				}
				if (((FrameBase)verified).Has<ShopState>(r))
				{
					stringBuilder.Append("Il2CppQuantum.ShopState\n");
				}
				if (((FrameBase)verified).Has<Shotgun>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Shotgun\n");
				}
				if (((FrameBase)verified).Has<Shuriken>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Shuriken\n");
				}
				if (((FrameBase)verified).Has<SkyYeetFinder>(r))
				{
					stringBuilder.Append("Il2CppQuantum.SkyYeetFinder\n");
				}
				if (((FrameBase)verified).Has<Sledgehammer>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Sledgehammer\n");
				}
				if (((FrameBase)verified).Has<SleepWithJoint>(r))
				{
					stringBuilder.Append("Il2CppQuantum.SleepWithJoint\n");
				}
				if (((FrameBase)verified).Has<SlotMachine>(r))
				{
					stringBuilder.Append("Il2CppQuantum.SlotMachine\n");
				}
				if (((FrameBase)verified).Has<SnapBudget>(r))
				{
					stringBuilder.Append("Il2CppQuantum.SnapBudget\n");
				}
				if (((FrameBase)verified).Has<SnapToOffset>(r))
				{
					stringBuilder.Append("Il2CppQuantum.SnapToOffset\n");
				}
				if (((FrameBase)verified).Has<SpawnShop>(r))
				{
					stringBuilder.Append("Il2CppQuantum.SpawnShop\n");
				}
				if (((FrameBase)verified).Has<SpecialArenaBehavior>(r))
				{
					stringBuilder.Append("Il2CppQuantum.SpecialArenaBehavior\n");
				}
				if (((FrameBase)verified).Has<Spectator>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Spectator\n");
				}
				if (((FrameBase)verified).Has<StartLineGate>(r))
				{
					stringBuilder.Append("Il2CppQuantum.StartLineGate\n");
				}
				if (((FrameBase)verified).Has<StickyWeapon>(r))
				{
					stringBuilder.Append("Il2CppQuantum.StickyWeapon\n");
				}
				if (((FrameBase)verified).Has<StraggleBoostSpawner>(r))
				{
					stringBuilder.Append("Il2CppQuantum.StraggleBoostSpawner\n");
				}
				if (((FrameBase)verified).Has<Stuck>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Stuck\n");
				}
				if (((FrameBase)verified).Has<StunState>(r))
				{
					stringBuilder.Append("Il2CppQuantum.StunState\n");
				}
				if (((FrameBase)verified).Has<SwitchButton>(r))
				{
					stringBuilder.Append("Il2CppQuantum.SwitchButton\n");
				}
				if (((FrameBase)verified).Has<SwitchTriggeredMovingTerrain>(r))
				{
					stringBuilder.Append("Il2CppQuantum.SwitchTriggeredMovingTerrain\n");
				}
				if (((FrameBase)verified).Has<Television>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Television\n");
				}
				if (((FrameBase)verified).Has<TrackAndShootAI>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TrackAndShootAI\n");
				}
				if (((FrameBase)verified).Has<TradePod>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TradePod\n");
				}
				if (((FrameBase)verified).Has<TrafficCarriageStaticDataComponent>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TrafficCarriageStaticDataComponent\n");
				}
				if (((FrameBase)verified).Has<TrafficCarriageTag>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TrafficCarriageTag\n");
				}
				if (((FrameBase)verified).Has<TrafficCarriages>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TrafficCarriages\n");
				}
				if (((FrameBase)verified).Has<TrafficReactions>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TrafficReactions\n");
				}
				if (((FrameBase)verified).Has<TrafficRoad>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TrafficRoad\n");
				}
				if (((FrameBase)verified).Has<TrafficSign>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TrafficSign\n");
				}
				if (((FrameBase)verified).Has<TrafficTruckStaticDataComponent>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TrafficTruckStaticDataComponent\n");
				}
				if (((FrameBase)verified).Has<TrainTrack>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TrainTrack\n");
				}
				if (((FrameBase)verified).Has<TramTrack>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TramTrack\n");
				}
				if (((FrameBase)verified).Has<TransferJoints>(r))
				{
					stringBuilder.Append("Il2CppQuantum.TransferJoints\n");
				}
				if (((FrameBase)verified).Has<Tutorial>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Tutorial\n");
				}
				if (((FrameBase)verified).Has<UnderWater>(r))
				{
					stringBuilder.Append("Il2CppQuantum.UnderWater\n");
				}
				if (((FrameBase)verified).Has<UniqueEquipment>(r))
				{
					stringBuilder.Append("Il2CppQuantum.UniqueEquipment\n");
				}
				if (((FrameBase)verified).Has<Vehicle>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Vehicle\n");
				}
				if (((FrameBase)verified).Has<VictoryCelebration>(r))
				{
					stringBuilder.Append("Il2CppQuantum.VictoryCelebration\n");
				}
				if (((FrameBase)verified).Has<Wet>(r))
				{
					stringBuilder.Append("Il2CppQuantum.Wet\n");
				}
				Core.Logger.Msg(stringBuilder.ToString());
			}
		}
	}
	public class Packet
	{
		[HarmonyPatch(typeof(PhotonController), "OnPlayerPropertiesUpdate")]
		public static class PhotonControllerPatch
		{
			private static void Postfix(Player targetPlayer, PhotonHashtable changedProps)
			{
				if (targetPlayer.IsLocal || !((Dictionary<Object, Object>)(object)changedProps).ContainsKey(Object.op_Implicit("Crowbar_Packet")))
				{
					return;
				}
				PhotonHashtable val = ((Il2CppObjectBase)changedProps[Object.op_Implicit("Crowbar_Packet")]).Cast<PhotonHashtable>();
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				string text = null;
				DictionaryEntryEnumerator enumerator = val.GetEnumerator();
				while (enumerator.MoveNext())
				{
					DictionaryEntry current = enumerator.Current;
					string text2 = current.Key.ToString();
					string text3 = current.Value.ToString();
					if (text2 == "__identifier")
					{
						text = text3;
					}
					else
					{
						dictionary[text2] = text3;
					}
				}
				if (text != null && callbacks.ContainsKey(text))
				{
					callbacks[text](targetPlayer, dictionary);
				}
			}
		}

		private const string CustomPropertyName = "Crowbar_Packet";

		private const string IdentifierKey = "__identifier";

		private static readonly Dictionary<string, Action<Player, Dictionary<string, string>>> callbacks = new Dictionary<string, Action<Player, Dictionary<string, string>>>();

		public string Identifier { get; }

		public Packet(string identifier, Action<Player, Dictionary<string, string>> callback)
		{
			if (callbacks.ContainsKey(identifier))
			{
				throw new ArgumentException("Identifier '" + identifier + "' is already in use.");
			}
			Identifier = identifier;
			callbacks[identifier] = callback;
		}

		public bool Send(Dictionary<string, string> dict)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Expected O, but got Unknown
			PhotonController instance = PhotonController.instance;
			RealtimeClient client = instance.client;
			Room currentRoom = client.CurrentRoom;
			if (client.CurrentRoom == null)
			{
				return false;
			}
			PhotonHashtable val = new PhotonHashtable();
			foreach (KeyValuePair<string, string> item in dict)
			{
				if (item.Key == "__identifier")
				{
					throw new ArgumentException("Do not use the key '__identifier'.");
				}
				((Dictionary<Object, Object>)(object)val).Add(Object.op_Implicit(item.Key), Object.op_Implicit(item.Value));
			}
			((Dictionary<Object, Object>)(object)val).Add(Object.op_Implicit("__identifier"), Object.op_Implicit(Identifier));
			PhotonHashtable val2 = new PhotonHashtable();
			((Dictionary<Object, Object>)(object)val2).Add(Object.op_Implicit("Crowbar_Packet"), (Object)(object)val);
			client.LocalPlayer.SetCustomProperties(val2, (PhotonHashtable)null);
			return true;
		}
	}
}