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.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using AirlockAPI.Attributes;
using AirlockAPI.Data;
using AirlockAPI.Debug;
using AirlockAPI.Handlers;
using AirlockAPI.Main;
using AirlockAPI.Managers;
using AirlockAPI.Patches;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Unity.IL2CPP;
using ExitGames.Client.Photon;
using Fusion;
using HarmonyLib;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.Injection;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.IO;
using Microsoft.CodeAnalysis;
using Photon.Realtime;
using SG.Airlock;
using SG.Airlock.Cutscenes;
using SG.Airlock.Localization;
using SG.Airlock.Network;
using SG.Airlock.Roles;
using SG.Airlock.UI.TitleScreen;
using SG.CoreLite;
using SG.LightUI;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("AirlockAPI")]
[assembly: AssemblyDescription("Modding API for Among Us 3D/VR")]
[assembly: AssemblyProduct("AirlockAPI")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: ComVisible(false)]
[assembly: Guid("5f9af3a0-9611-47fa-95e6-c2d57052dedc")]
[assembly: AssemblyFileVersion("1.0.1.0")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("1.0.1.0")]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace AirlockAPI.Patches
{
	[HarmonyPatch(typeof(RoleManager), "AssignRoles")]
	public class AssignRolesPatch
	{
		public static bool Prefix(RoleManager __instance)
		{
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				return CustomGameHandler.Current.OnBeforeAssignRoles();
			}
			return true;
		}

		public static void Postfix(RoleManager __instance)
		{
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				CustomGameHandler.Current.OnAfterAssignRoles();
			}
		}
	}
	[HarmonyPatch(typeof(GameStateManager), "EndGame")]
	public class EndGamePatch
	{
		public static bool Prefix(GameStateManager __instance, GameTeam winningTeam)
		{
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				return CustomGameHandler.Current.OnGameEnd(ref winningTeam);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(VoteManager), "EndVote")]
	public class EndVotePatch
	{
		public static bool Prefix(VoteManager __instance)
		{
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				return CustomGameHandler.Current.OnAllVotesCast();
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(PunishmentController), "OnEvent")]
	public class OnEventPatch
	{
		public static void Prefix(EventData photonEvent)
		{
			if (photonEvent.Code != 125)
			{
				return;
			}
			Object customData = photonEvent.CustomData;
			Hashtable val = (Hashtable)(object)((customData is Hashtable) ? customData : null);
			if (val == null)
			{
				return;
			}
			Object obj = val[(byte)0];
			String val2 = (String)(object)((obj is String) ? obj : null);
			if (val2 != null)
			{
				Object obj2 = val[(byte)1];
				Hashtable val3 = (Hashtable)(object)((obj2 is Hashtable) ? obj2 : null);
				if (val3 != null)
				{
					NetworkManager.OnEvent(new AirlockEventInfo(int.Parse(String.op_Implicit(val2)), val3));
				}
			}
		}
	}
	[HarmonyPatch(typeof(GamemodeSelectionMenu), "OnModeSelect")]
	public static class OnModeSelectPatch
	{
		public static void Prefix(GamemodeSelectionMenu __instance, MapModeSelect modeSelect)
		{
			if (modeSelect.ModeInfo.ModeName.StartsWith("<size=0>MODDED</size><color=yellow>"))
			{
				CurrentMode.Modded = true;
				CurrentMode.Name = modeSelect.ModeInfo.ModeName.Replace("<size=0>MODDED</size><color=yellow>", "");
			}
			else
			{
				CurrentMode.Modded = false;
				CurrentMode.Name = modeSelect.ModeInfo.ModeName;
			}
			if (CurrentMode.Modded)
			{
				__instance._startButton._isDisabled = __instance._isQuickMatch;
			}
			else
			{
				__instance._startButton._isDisabled = false;
			}
			Logging.Log("Mode: " + CurrentMode.Name + " | Modded Gamemode: " + CurrentMode.Modded);
		}
	}
	[HarmonyPatch(typeof(NetworkRunner), "Fusion_Simulation_ICallbacks_OnReliableData")]
	public static class RpcRecievedPatch
	{
		private static void AddParameters(BinaryReader reader, ref object[] args, int count, PlayerRef host, PlayerRef player, ref int targetPlayer)
		{
			//IL_0007: 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)
			int num = 0;
			for (int i = 0; i < count; i++)
			{
				object obj = ReadValue(reader, host, player, ref targetPlayer);
				if (obj == null)
				{
					num++;
				}
				else
				{
					args[i - num] = obj;
				}
			}
		}

		private static object ReadValue(BinaryReader reader, PlayerRef host, PlayerRef player, ref int targetPlayer)
		{
			//IL_00a8: 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_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: 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)
			byte b = reader.ReadByte();
			switch (b)
			{
			case 1:
				return reader.ReadInt32();
			case 2:
				return reader.ReadSingle();
			case 3:
				return reader.ReadByte();
			case 4:
				return reader.ReadBoolean();
			case 5:
				return reader.ReadString();
			case 6:
				return GameObject.Find(reader.ReadString());
			case 7:
				return PlayerRef.op_Implicit(reader.ReadInt32());
			case 8:
			{
				float num18 = reader.ReadSingle();
				float num19 = reader.ReadSingle();
				float num20 = reader.ReadSingle();
				return (object)new Vector3(num18, num19, num20);
			}
			case 9:
			{
				float num15 = reader.ReadSingle();
				float num16 = reader.ReadSingle();
				float num17 = reader.ReadSingle();
				return Quaternion.Euler(new Vector3(num15, num16, num17));
			}
			case 10:
				return GameObject.Find(reader.ReadString()).transform;
			case 11:
			{
				float num12 = reader.ReadSingle();
				float num13 = reader.ReadSingle();
				float num14 = reader.ReadSingle();
				return (object)new Color(num12, num13, num14);
			}
			case 12:
			{
				byte b2 = reader.ReadByte();
				byte b3 = reader.ReadByte();
				byte b4 = reader.ReadByte();
				byte b5 = reader.ReadByte();
				return (object)new Color32(b2, b3, b4, b5);
			}
			case 13:
			{
				float num8 = reader.ReadSingle();
				float num9 = reader.ReadSingle();
				float num10 = reader.ReadSingle();
				float num11 = reader.ReadSingle();
				return (object)new Rect(num8, num9, num10, num11);
			}
			case 14:
			{
				float num6 = reader.ReadSingle();
				float num7 = reader.ReadSingle();
				return (object)new Vector2(num6, num7);
			}
			case 15:
			{
				float num2 = reader.ReadSingle();
				float num3 = reader.ReadSingle();
				float num4 = reader.ReadSingle();
				float num5 = reader.ReadSingle();
				return (object)new Vector4(num2, num3, num4, num5);
			}
			case 16:
			{
				int num = reader.ReadInt32();
				List<object> list = new List<object>(num);
				for (int i = 0; i < num; i++)
				{
					list.Add(ReadValue(reader, host, player, ref targetPlayer));
				}
				return list;
			}
			case 200:
				targetPlayer = reader.ReadInt32();
				return null;
			default:
				Logging.Warn($"Unknown tag: {b}! Skipping value..");
				return null;
			}
		}

		public static void Prefix(NetworkRunner __instance, PlayerRef player, Il2CppStructArray<byte> dataArray)
		{
			//IL_009a: 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)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			Logging.Log("RPC_RECIEVED");
			int targetPlayer = -1;
			if ((Object)(object)NetworkManager.Network == (Object)null)
			{
				NetworkManager.Network = Object.FindObjectOfType<AirlockNetworkRunner>();
				if ((Object)(object)NetworkManager.Network == (Object)null)
				{
					return;
				}
			}
			using MemoryStream input = new MemoryStream(Il2CppArrayBase<byte>.op_Implicit((Il2CppArrayBase<byte>)(object)dataArray));
			using BinaryReader binaryReader = new BinaryReader(input, Encoding.UTF8);
			PlayerRef host = default(PlayerRef);
			((NetworkRunner)NetworkManager.Network).TryGetHostPlayer(ref host);
			Logging.Log(((PlayerRef)(ref host)).PlayerId.ToString());
			string text = binaryReader.ReadString();
			Logging.Log(text);
			int num = binaryReader.ReadInt32();
			object[] args = new object[num];
			if (num != 0)
			{
				AddParameters(binaryReader, ref args, num, host, player, ref targetPlayer);
			}
			NetworkManager.OnRecievedRpc(text, PlayerRef.op_Implicit(player), targetPlayer, args);
		}
	}
	[HarmonyPatch(typeof(CutsceneManager), "ShowEjected")]
	public class ShowEjectedPatch1
	{
		public static bool Prefix(CutsceneManager __instance, PlayerRef playerEjected, GameRole playerEjectedRole, bool onlyShowImpostors, int aliveImposters, int aliveCrewmates)
		{
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				PlayerState ejectedPlayer = GameObject.Find("PlayerState (" + ((PlayerRef)(ref playerEjected)).PlayerId + ")").GetComponent<PlayerState>();
				return CustomGameHandler.Current.OnPlayerEjected(ref ejectedPlayer, ref playerEjectedRole);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CutsceneManager), "ShowAnonymousEjected")]
	public class ShowEjectedPatch2
	{
		public static bool Prefix(CutsceneManager __instance, PlayerRef playerEjected, int aliveImposters, int aliveCrewmates)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				PlayerState ejectedPlayer = GameObject.Find("PlayerState (" + ((PlayerRef)(ref playerEjected)).PlayerId + ")").GetComponent<PlayerState>();
				GameRole role = CustomGameHandler.Current.GetTrueRole(ejectedPlayer);
				return CustomGameHandler.Current.OnPlayerEjected(ref ejectedPlayer, ref role);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CutsceneManager), "ShowNoEjected")]
	public class ShowEjectedPatch3
	{
		public static bool Prefix(CutsceneManager __instance, int aliveImposters)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				PlayerState ejectedPlayer = null;
				GameRole role = (GameRole)0;
				return CustomGameHandler.Current.OnPlayerEjected(ref ejectedPlayer, ref role);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CutsceneManager), "ShowDebugEjected")]
	public class ShowEjectedPatch4
	{
		public static bool Prefix(CutsceneManager __instance, PlayerRef playerEjected, bool wasImposter, int aliveImposters, int cutsceneIndex)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				PlayerState ejectedPlayer = GameObject.Find("PlayerState (" + ((PlayerRef)(ref playerEjected)).PlayerId + ")").GetComponent<PlayerState>();
				GameRole role = CustomGameHandler.Current.GetTrueRole(ejectedPlayer);
				return CustomGameHandler.Current.OnPlayerEjected(ref ejectedPlayer, ref role);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(GameStateManager), "StartGame")]
	public class StartGamePatch
	{
		public static bool Prefix(GameStateManager __instance)
		{
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				return CustomGameHandler.Current.OnGameStart();
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(NetworkedKillBehaviour), "RPC_TargetedAction")]
	public class TargetedActionPatch
	{
		public static bool Prefix(NetworkedKillBehaviour __instance, ref PlayerRef targetedPlayer, ref PlayerRef perpetrator, ref int action)
		{
			PlayerState killer = GameObject.Find("PlayerState (" + ((PlayerRef)(ref perpetrator)).PlayerId + ")").GetComponent<PlayerState>();
			PlayerState victim = GameObject.Find("PlayerState (" + ((PlayerRef)(ref targetedPlayer)).PlayerId + ")").GetComponent<PlayerState>();
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				return CustomGameHandler.Current.OnTargetedAction(ref killer, ref victim, ref action);
			}
			return true;
		}
	}
	[HarmonyPatch]
	public class VotePatch
	{
		[HarmonyPatch(typeof(VoteManager), "RPC_Vote", new Type[]
		{
			typeof(PlayerRef),
			typeof(PlayerRef),
			typeof(RpcInfo)
		})]
		[HarmonyPrefix]
		public static bool Prefix1(PlayerRef voteAgainstPlayer, PlayerRef sourcePlayer, RpcInfo info)
		{
			PlayerState voter = GameObject.Find("PlayerState (" + ((PlayerRef)(ref sourcePlayer)).PlayerId + ")").GetComponent<PlayerState>();
			PlayerState voted = GameObject.Find("PlayerState (" + ((PlayerRef)(ref voteAgainstPlayer)).PlayerId + ")").GetComponent<PlayerState>();
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				return CustomGameHandler.Current.OnPlayerVoted(ref voter, ref voted);
			}
			return true;
		}

		[HarmonyPatch(typeof(VoteManager), "RPC_Vote", new Type[]
		{
			typeof(PlayerRef),
			typeof(RpcInfo)
		})]
		[HarmonyPrefix]
		public static bool Prefix2(PlayerRef sourcePlayer, RpcInfo info)
		{
			PlayerState voter = GameObject.Find("PlayerState (" + ((PlayerRef)(ref sourcePlayer)).PlayerId + ")").GetComponent<PlayerState>();
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				return CustomGameHandler.Current.OnPlayerVotedSkip(ref voter);
			}
			return true;
		}
	}
	[HarmonyPatch]
	public class CallVote
	{
		[HarmonyPatch(typeof(VoteManager), "RPC_CallVote", new Type[]
		{
			typeof(int),
			typeof(PlayerRef),
			typeof(NetworkBool),
			typeof(RpcInfo)
		})]
		[HarmonyPrefix]
		public static bool Prefix1(int foundPlayer, PlayerRef sourcePlayer, NetworkBool forceVote, RpcInfo info)
		{
			PlayerState reportingPlayer = GameObject.Find("PlayerState (" + ((PlayerRef)(ref sourcePlayer)).PlayerId + ")").GetComponent<PlayerState>();
			PlayerState bodyReported = GameObject.Find("PlayerState (" + foundPlayer + ")").GetComponent<PlayerState>();
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				if (CustomGameHandler.Current.OnVotingBegan(ref bodyReported, ref reportingPlayer))
				{
					return CustomGameHandler.Current.OnBodyReported(ref bodyReported, ref reportingPlayer);
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(VoteManager), "RPC_CallVote", new Type[]
		{
			typeof(PlayerRef),
			typeof(NetworkBool),
			typeof(RpcInfo)
		})]
		[HarmonyPrefix]
		public static bool Prefix(PlayerRef sourcePlayer, NetworkBool forceVote, RpcInfo info)
		{
			PlayerState reportingPlayer = GameObject.Find("PlayerState (" + ((PlayerRef)(ref sourcePlayer)).PlayerId + ")").GetComponent<PlayerState>();
			PlayerState bodyReported = null;
			if (Object.op_Implicit((Object)(object)CustomGameHandler.Current))
			{
				if (CustomGameHandler.Current.OnVotingBegan(ref bodyReported, ref reportingPlayer))
				{
					return CustomGameHandler.Current.OnMeetingCalled(ref reportingPlayer);
				}
				return false;
			}
			return true;
		}
	}
}
namespace AirlockAPI.Managers
{
	internal static class ConvertManager
	{
		public static Il2CppArrayBase<PlayerRef> PlayerIEnumeratorToArray<PlayerRef>(this IEnumerable<PlayerRef> source)
		{
			return MonoLinqHelper.ToArray<PlayerRef>(source);
		}
	}
	public static class GamemodeManager
	{
		internal static List<string> RegisteredCustomModes = new List<string>();

		internal static List<string> RegisteredCustomMaps = new List<string>();

		internal static Dictionary<string, Dictionary<string, GameModes>> QueuedCustomModes = new Dictionary<string, Dictionary<string, GameModes>>();

		internal static Dictionary<string, MapInfo> QueuedCustomMaps = new Dictionary<string, MapInfo>();

		public static List<Type> GamemodeHandlerTypes = new List<Type>();

		internal static void CheckForMapOrMode()
		{
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (QueuedCustomModes.Count != 0)
			{
				CreateMode(QueuedCustomModes.Keys.ToList()[0], QueuedCustomModes.Values.ToList()[0].Keys.ToList()[0], QueuedCustomModes.Values.ToList()[0].Values.ToList()[0]);
				QueuedCustomModes.Remove(QueuedCustomModes.Keys.ToList()[0]);
			}
			if (QueuedCustomMaps.Count != 0)
			{
				CreateMap(QueuedCustomMaps.Keys.ToList()[0], QueuedCustomMaps.Values.ToList()[0]);
				QueuedCustomMaps.Remove(QueuedCustomMaps.Keys.ToList()[0]);
			}
		}

		public static void AddMap(string name, MapInfo mapTemplate)
		{
			QueuedCustomMaps.Add(name, mapTemplate);
			CheckForMapOrMode();
		}

		public static void AddMode(string name, string description, GameModes useGamemodeScript = (GameModes)0)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			QueuedCustomModes.Add(name, new Dictionary<string, GameModes> { { description, useGamemodeScript } });
			CheckForMapOrMode();
		}

		internal unsafe static void CreateMode(string name, string description, GameModes useGamemodeScript = (GameModes)0, Sprite image = null)
		{
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected O, but got Unknown
			//IL_014c: 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_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Expected O, but got Unknown
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0278: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			GamemodeSelectionMenu val = Object.FindObjectOfType<GamemodeSelectionMenu>(true);
			if (!((Object)(object)val != (Object)null))
			{
				return;
			}
			if (val._modeInfoCollection._activeModesAndMaps.RuntimeModes.Count >= 4)
			{
				foreach (GamemodeSelectionMenu item in Object.FindObjectsOfType<GamemodeSelectionMenu>(true))
				{
					MapModeSelect[] array = Il2CppArrayBase<MapModeSelect>.op_Implicit(((Component)item._modeLayout).GetComponentsInChildren<MapModeSelect>(true));
					int num = 0;
					MapModeSelect[] array2 = array;
					foreach (MapModeSelect val2 in array2)
					{
						((Component)val2).transform.localScale = new Vector3(0.6f, 0.6f, 0.6f);
						if (num == 0)
						{
							Object.Instantiate<GameObject>(((Component)val2).gameObject, ((Component)val2).transform.parent).transform.localScale = new Vector3(0.6f, 0.6f, 0.6f);
						}
						num++;
					}
					((LUIElement)item._modeLayout)._totalHeight = 30f;
					((LUIElement)item._modeLayout).SetHeight(125f);
				}
			}
			if (RegisteredCustomModes.Contains(name + "_" + description))
			{
				val._modeInfoCollection._activeModesAndMaps.RuntimeModes.Add("<size=0>MODDED</size><color=yellow>" + name);
				return;
			}
			ModeInfo val3 = new ModeInfo();
			if ((int)useGamemodeScript == 0)
			{
				val3.Mode = val._modeInfoCollection.Modes[0].Mode;
				val3.Maps = val._modeInfoCollection.Modes[0].Maps;
			}
			else
			{
				ModeInfo modeInfo = val._modeInfoCollection.GetModeInfo(useGamemodeScript);
				if (modeInfo != null)
				{
					Logging.Debug_Log("Using " + ((object)(*(GameModes*)(&useGamemodeScript))/*cast due to .constrained prefix*/).ToString() + " as a template...");
					val3.Mode = modeInfo.Mode;
					val3.Maps = modeInfo.Maps;
				}
				else
				{
					Logging.Debug_Warn(((object)(*(GameModes*)(&useGamemodeScript))/*cast due to .constrained prefix*/).ToString() + " returned a null ModeScript! Using default...");
					val3.Mode = val._modeInfoCollection.Modes[0].Mode;
					val3.Maps = val._modeInfoCollection.Modes[0].Maps;
				}
			}
			val3.ModeName = "<size=0>MODDED</size><color=yellow>" + name;
			val3.ModeNameKey = new UserString();
			val3.ModeNameKey.DefaultValue = val3.ModeName;
			val3.ModeNameKey.FormattedPreview = val3.ModeName;
			val3.ModeDescriptionKey = new UserString();
			val3.ModeDescriptionKey.DefaultValue = description;
			val3.ModeDescriptionKey.FormattedPreview = description;
			if (Object.op_Implicit((Object)(object)image))
			{
				val3.ModeSprite = image;
			}
			if (!val._modeInfoCollection.Modes.Contains(val3))
			{
				val._modeInfoCollection.Modes.Add(val3);
			}
			val._modeInfoCollection._activeModesAndMaps.RuntimeModes.Add(val3.ModeName);
			RegisteredCustomModes.Add(name + "_" + description);
		}

		internal static void CreateMap(string name, MapInfo mapTemplate)
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Expected O, but got Unknown
			//IL_009f: 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_00c3: 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)
			GamemodeSelectionMenu val = Object.FindObjectOfType<GamemodeSelectionMenu>(true);
			if (!((Object)(object)val != (Object)null) || val._mapInfoCollection._activeModesAndMaps.RuntimeMaps.Count >= 10)
			{
				return;
			}
			RegisteredCustomMaps.Add(name);
			if (RegisteredCustomMaps.Contains(name))
			{
				val._modeInfoCollection._activeModesAndMaps.RuntimeMaps.Add("<size=0>MODDED</size><color=orange>" + name);
				return;
			}
			MapInfo val2 = new MapInfo();
			val2.MapName = "<size=0>MODDED</size><color=orange>" + name;
			val2.Scene = mapTemplate.Scene;
			val2.MapIndex = RegisteredCustomMaps.Count + 2;
			val2.LUIMapCoordsOff = mapTemplate.LUIMapCoordsOff;
			val2.LUIMapCoordsOn = mapTemplate.LUIMapCoordsOn;
			val2.MapSprite = mapTemplate.MapSprite;
			val2.LUIMapCoordsHover = mapTemplate.LUIMapCoordsHover;
			val2.LUIMapCoordsHoverOn = mapTemplate.LUIMapCoordsHoverOn;
			val2.TransitionSpace = mapTemplate.TransitionSpace;
			if (!val._mapInfoCollection.Maps.Contains(val2))
			{
				val._mapInfoCollection.Maps.Add(val2);
			}
			val._mapInfoCollection._activeModesAndMaps.RuntimeMaps.Add(val2.MapName);
		}
	}
	public static class NetworkManager
	{
		public enum RpcTarget
		{
			All,
			AllInclusive,
			Host
		}

		public enum RpcCaller
		{
			All,
			Host
		}

		internal static AirlockNetworkRunner Network;

		internal static VoiceChatManager vc;

		internal static Dictionary<string, AirlockRpc> StringToAirlockRpc = new Dictionary<string, AirlockRpc>();

		internal static Dictionary<AirlockRpc, MethodBase> RegisteredRpcs = new Dictionary<AirlockRpc, MethodBase>();

		internal static List<Action<AirlockEventInfo>> onEventCallbacks = new List<Action<AirlockEventInfo>>();

		public static void SendRpc(string rpc, params object[] param)
		{
			ProcessSendingRpc(rpc, -1, param);
		}

		public static void SendRpc(string rpc, int targetPlayer = -1, params object[] param)
		{
			ProcessSendingRpc(rpc, targetPlayer, param);
		}

		internal static bool ValidateVC()
		{
			if ((Object)(object)vc != (Object)null)
			{
				return true;
			}
			VoiceChatManager val = Object.FindObjectOfType<VoiceChatManager>();
			if ((Object)(object)val != (Object)null)
			{
				vc = val;
				return true;
			}
			return false;
		}

		public static void AddOnEventCallback(Action<AirlockEventInfo> eventInfo)
		{
			if (!onEventCallbacks.Contains(eventInfo))
			{
				onEventCallbacks.Add(eventInfo);
			}
		}

		internal static void OnEvent(AirlockEventInfo eventInfo)
		{
			foreach (Action<AirlockEventInfo> onEventCallback in onEventCallbacks)
			{
				onEventCallback(eventInfo);
			}
		}

		internal static void RaiseEvent(int eventCode, Hashtable content, RaiseEventOptions raiseEventOptions, SendOptions sendOptions)
		{
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Expected O, but got Unknown
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			if (!ValidateVC())
			{
				Logging.Warn("RaiseEvent can only be called within a game!");
				return;
			}
			if ((Object)(object)vc.VoiceConnection == (Object)null)
			{
				Logging.Warn("RaiseEvent can only be called within a game!");
				return;
			}
			if (vc.VoiceConnection.Client == null)
			{
				Logging.Warn("RaiseEvent can only be called within a game!");
				return;
			}
			Hashtable val = new Hashtable();
			Il2CppStructArray<char> val2 = new Il2CppStructArray<char>(eventCode.ToString().ToCharArray());
			val.Add((byte)0, (Object)new String(val2));
			val.Add((byte)1, (Object)(object)content);
			((LoadBalancingClient)vc.VoiceConnection.Client).OpRaiseEvent((byte)125, (Object)(object)val, raiseEventOptions, sendOptions);
		}

		public static double GetPing()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Network))
			{
				return ((NetworkRunner)Network).Simulation.GetPlayerRtt(((NetworkRunner)Network).LocalPlayer);
			}
			return 0.0;
		}

		public static double GetPing(PlayerState player)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)Network))
			{
				return ((NetworkRunner)Network).Simulation.GetPlayerRtt(PlayerRef.op_Implicit(player.PlayerId));
			}
			return 0.0;
		}

		private static void WriteValue(BinaryWriter writer, object value)
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: 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)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: 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_0213: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
			//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_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0259: Unknown result type (might be due to invalid IL or missing references)
			//IL_0266: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a3: 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_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: 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_0333: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			if (!(value is int value2))
			{
				if (!(value is float value3))
				{
					if (!(value is byte value4))
					{
						if (!(value is bool value5))
						{
							if (!(value is string value6))
							{
								GameObject val = (GameObject)((value is GameObject) ? value : null);
								if (val == null)
								{
									if (!(value is PlayerRef val2))
									{
										if (!(value is Vector3 val3))
										{
											if (!(value is Quaternion val4))
											{
												Transform val5 = (Transform)((value is Transform) ? value : null);
												if (val5 == null)
												{
													if (!(value is Color val6))
													{
														if (!(value is Color32 val7))
														{
															if (!(value is Rect val8))
															{
																if (!(value is Vector2 val9))
																{
																	if (!(value is Vector4 val10))
																	{
																		if (value is IList list)
																		{
																			writer.Write((byte)16);
																			writer.Write(list.Count);
																			{
																				foreach (object item in list)
																				{
																					WriteValue(writer, item);
																				}
																				return;
																			}
																		}
																		throw new InvalidOperationException($"Unsupported value type: {value?.GetType()}");
																	}
																	writer.Write((byte)15);
																	writer.Write(val10.x);
																	writer.Write(val10.y);
																	writer.Write(val10.z);
																	writer.Write(val10.w);
																}
																else
																{
																	writer.Write((byte)14);
																	writer.Write(val9.x);
																	writer.Write(val9.y);
																}
															}
															else
															{
																writer.Write((byte)13);
																writer.Write(((Rect)(ref val8)).x);
																writer.Write(((Rect)(ref val8)).y);
																writer.Write(((Rect)(ref val8)).width);
																writer.Write(((Rect)(ref val8)).height);
															}
														}
														else
														{
															writer.Write((byte)12);
															writer.Write(val7.r);
															writer.Write(val7.g);
															writer.Write(val7.b);
															writer.Write(val7.a);
														}
													}
													else
													{
														writer.Write((byte)11);
														writer.Write(val6.r);
														writer.Write(val6.g);
														writer.Write(val6.b);
														writer.Write(val6.a);
													}
												}
												else
												{
													writer.Write((byte)10);
													writer.Write(TransformExtensions.GetTransformPath(val5));
												}
											}
											else
											{
												writer.Write((byte)9);
												writer.Write(val4.x);
												writer.Write(val4.y);
												writer.Write(val4.z);
												writer.Write(val4.w);
											}
										}
										else
										{
											writer.Write((byte)8);
											writer.Write(val3.x);
											writer.Write(val3.y);
											writer.Write(val3.z);
										}
									}
									else
									{
										writer.Write((byte)7);
										writer.Write(((PlayerRef)(ref val2)).PlayerId);
									}
								}
								else
								{
									writer.Write((byte)6);
									writer.Write(TransformExtensions.GetTransformPath(val.transform));
								}
							}
							else
							{
								writer.Write((byte)5);
								writer.Write(value6);
							}
						}
						else
						{
							writer.Write((byte)4);
							writer.Write(value5);
						}
					}
					else
					{
						writer.Write((byte)3);
						writer.Write(value4);
					}
				}
				else
				{
					writer.Write((byte)2);
					writer.Write(value3);
				}
			}
			else
			{
				writer.Write((byte)1);
				writer.Write(value2);
			}
		}

		private static void WriteParameters(BinaryWriter writer, params object[] param)
		{
			foreach (object value in param)
			{
				WriteValue(writer, value);
			}
		}

		internal static void ProcessSendingRpc(string rpc, int targetPlayer = -1, params object[] param)
		{
			//IL_006c: 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_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: 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)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Network == (Object)null)
			{
				Network = Object.FindObjectOfType<AirlockNetworkRunner>();
				if ((Object)(object)Network == (Object)null)
				{
					return;
				}
			}
			using MemoryStream memoryStream = new MemoryStream();
			using BinaryWriter binaryWriter = new BinaryWriter(memoryStream, Encoding.UTF8, leaveOpen: true);
			binaryWriter.Write(rpc);
			binaryWriter.Write(param.Length);
			if (param.Length != 0)
			{
				WriteParameters(binaryWriter, param);
			}
			PlayerRef val = default(PlayerRef);
			((NetworkRunner)Network).TryGetHostPlayer(ref val);
			AirlockRpc airlockRpc = StringToAirlockRpc[rpc];
			if (val != ((NetworkRunner)Network).LocalPlayer && targetPlayer != -1)
			{
				binaryWriter.Write((byte)200);
				binaryWriter.Write(targetPlayer);
			}
			binaryWriter.Flush();
			byte[] array = memoryStream.ToArray();
			if (targetPlayer != -1)
			{
				if (PlayerRef.op_Implicit(targetPlayer) == val)
				{
					RpcRecievedPatch.Prefix((NetworkRunner)(object)Network, val, Il2CppStructArray<byte>.op_Implicit(array));
				}
				else
				{
					((NetworkRunner)Network).SendReliableDataToPlayer(PlayerRef.op_Implicit(targetPlayer), Il2CppStructArray<byte>.op_Implicit(array));
				}
				return;
			}
			PlayerRef localPlayer;
			switch (airlockRpc.RpcTarget)
			{
			case RpcTarget.All:
			{
				foreach (PlayerRef item in ((NetworkRunner)Network).ActivePlayers.PlayerIEnumeratorToArray<PlayerRef>())
				{
					PlayerRef current2 = item;
					int playerId2 = ((PlayerRef)(ref current2)).PlayerId;
					localPlayer = ((NetworkRunner)Network).LocalPlayer;
					if (playerId2 != ((PlayerRef)(ref localPlayer)).PlayerId)
					{
						((NetworkRunner)Network).SendReliableDataToPlayer(current2, Il2CppStructArray<byte>.op_Implicit(array));
					}
				}
				break;
			}
			case RpcTarget.AllInclusive:
			{
				foreach (PlayerRef item2 in ((NetworkRunner)Network).ActivePlayers.PlayerIEnumeratorToArray<PlayerRef>())
				{
					PlayerRef current = item2;
					int playerId = ((PlayerRef)(ref current)).PlayerId;
					localPlayer = ((NetworkRunner)Network).LocalPlayer;
					if (playerId == ((PlayerRef)(ref localPlayer)).PlayerId)
					{
						RpcRecievedPatch.Prefix((NetworkRunner)(object)Network, val, Il2CppStructArray<byte>.op_Implicit(array));
					}
					else
					{
						((NetworkRunner)Network).SendReliableDataToPlayer(current, Il2CppStructArray<byte>.op_Implicit(array));
					}
				}
				break;
			}
			case RpcTarget.Host:
				localPlayer = ((NetworkRunner)Network).LocalPlayer;
				if (((PlayerRef)(ref localPlayer)).PlayerId == 9)
				{
					RpcRecievedPatch.Prefix((NetworkRunner)(object)Network, val, Il2CppStructArray<byte>.op_Implicit(array));
				}
				else
				{
					((NetworkRunner)Network).SendReliableDataToPlayer(((NetworkRunner)Network).LocalPlayer, Il2CppStructArray<byte>.op_Implicit(array));
				}
				break;
			}
		}

		internal static void OnRecievedRpc(string rpc, int sender, params object[] args)
		{
			OnRecievedRpc(rpc, sender, -1, args);
		}

		internal static void OnRecievedRpc(string rpc, int sender, int targetPlayer, params object[] args)
		{
			//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)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			if (!StringToAirlockRpc.TryGetValue(rpc, out AirlockRpc value))
			{
				Logging.Debug_Warn("RPC: " + rpc + " was not found in StringToAirlockRpc! Have you registered it correctly?");
			}
			else
			{
				if (value == null)
				{
					return;
				}
				if (!RegisteredRpcs.TryGetValue(value, out MethodBase value2))
				{
					Logging.Debug_Warn("RPC: " + rpc + " was not found in RegisteredRpcs! Have you registered it correctly?");
				}
				else
				{
					if (!(value2 != null))
					{
						return;
					}
					PlayerRef val = default(PlayerRef);
					((NetworkRunner)Network).TryGetHostPlayer(ref val);
					if (value.RpcCaller == RpcCaller.Host && val != PlayerRef.op_Implicit(sender))
					{
						return;
					}
					ParameterInfo[] parameters = value2.GetParameters();
					if (parameters.Count() != 0 && parameters.Last().ParameterType == typeof(AirlockRpcInfo))
					{
						AirlockRpcInfo airlockRpcInfo = new AirlockRpcInfo
						{
							Rpc = rpc,
							Target = value.RpcTarget,
							Caller = value.RpcCaller,
							Sender = PlayerRef.op_Implicit(sender)
						};
						args = CollectionExtensions.AddItem<object>((IEnumerable<object>)args, (object)airlockRpcInfo).ToArray();
					}
					switch (value.RpcTarget)
					{
					case RpcTarget.All:
					{
						PlayerRef localPlayer = ((NetworkRunner)Network).LocalPlayer;
						if (sender != ((PlayerRef)(ref localPlayer)).PlayerId)
						{
							InvokeRpc(value2, args);
						}
						break;
					}
					case RpcTarget.AllInclusive:
						InvokeRpc(value2, args);
						break;
					case RpcTarget.Host:
						if (val == ((NetworkRunner)Network).LocalPlayer)
						{
							InvokeRpc(value2, args);
						}
						break;
					}
				}
			}
		}

		internal static void InvokeRpc(MethodBase method, params object[] args)
		{
			method.Invoke(null, args);
		}
	}
}
namespace AirlockAPI.Main
{
	[BepInPlugin("com.airlockapi.youtubey", "AirlockAPI", "1.0.1")]
	internal class Loader : BasePlugin
	{
		public static Loader Instance;

		private Harmony harmony;

		public override void Load()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			harmony = new Harmony("com.airlockapi.youtubey");
			harmony.PatchAll();
			Instance = this;
			Type[] types = Assembly.GetExecutingAssembly().GetTypes();
			foreach (Type type in types)
			{
				if (type.IsClass && !type.IsAbstract && type.IsSubclassOf(typeof(MonoBehaviour)) && !ClassInjector.IsTypeRegisteredInIl2Cpp(type))
				{
					ClassInjector.RegisterTypeInIl2Cpp(type);
				}
			}
			SceneManager.sceneLoaded += UnityAction<Scene, LoadSceneMode>.op_Implicit((Action<Scene, LoadSceneMode>)OnSceneLoaded);
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
		{
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			string name = ((Scene)(ref scene)).name;
			if (name == "Boot")
			{
				PluginInfo[] array = ((BaseChainloader<BasePlugin>)(object)IL2CPPChainloader.Instance).Plugins.Values.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					Assembly assembly = array[i].Instance?.GetType().Assembly;
					if (!(assembly != null))
					{
						continue;
					}
					Type[] types = assembly.GetTypes();
					foreach (Type type in types)
					{
						MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
						foreach (MethodInfo methodInfo in methods)
						{
							AirlockRpc customAttribute = methodInfo.GetCustomAttribute<AirlockRpc>();
							if (customAttribute != null)
							{
								NetworkManager.StringToAirlockRpc.Add(customAttribute.RpcName, customAttribute);
								NetworkManager.RegisteredRpcs.Add(customAttribute, methodInfo);
								Logging.Debug_Log("Found RPC: " + customAttribute.RpcName);
							}
						}
						if (type.IsClass && !type.IsAbstract && type.IsSubclassOf(typeof(CustomGameHandler)))
						{
							if (!ClassInjector.IsTypeRegisteredInIl2Cpp(type))
							{
								ClassInjector.RegisterTypeInIl2Cpp(type);
							}
							GamemodeManager.GamemodeHandlerTypes.Add(type);
							Logging.Debug_Log("Found Gamemode Script: " + type.Name);
						}
					}
				}
			}
			if (!(name != "Boot") || !(name != "Title") || !CurrentMode.IsHosting)
			{
				return;
			}
			foreach (Type gamemodeHandlerType in GamemodeManager.GamemodeHandlerTypes)
			{
				if (gamemodeHandlerType.Name.ToLower().Replace(" ", "").Contains(CurrentMode.Name.ToLower().Replace(" ", "")))
				{
					new GameObject("AIRLOCKAPI").AddComponent(Il2CppType.From(gamemodeHandlerType));
				}
			}
		}
	}
}
namespace AirlockAPI.Handlers
{
	public class CustomGameHandler : MonoBehaviour
	{
		public static CustomGameHandler Current;

		public Dictionary<PlayerState, GameRole> AssignedRoles = new Dictionary<PlayerState, GameRole>();

		public GameStateManager State;

		public RoleManager Role;

		public VoteManager Vote;

		private void Awake()
		{
			if ((Object)(object)Current == (Object)null)
			{
				Current = this;
				Current.State = Object.FindObjectOfType<GameStateManager>();
				Current.Role = Object.FindObjectOfType<RoleManager>();
				Current.Vote = Object.FindObjectOfType<VoteManager>();
			}
			else
			{
				Object.Destroy((Object)(object)this);
			}
		}

		public virtual bool OnTargetedAction(ref PlayerState killer, ref PlayerState victim, ref int action)
		{
			return true;
		}

		public virtual bool OnPlayerVoted(ref PlayerState voter, ref PlayerState voted)
		{
			return true;
		}

		public virtual bool OnPlayerVotedSkip(ref PlayerState voter)
		{
			return true;
		}

		public virtual bool OnPlayerEjected(ref PlayerState ejectedPlayer, ref GameRole role)
		{
			return true;
		}

		public virtual bool OnMeetingCalled(ref PlayerState reportingPlayer)
		{
			return true;
		}

		public virtual bool OnBodyReported(ref PlayerState bodyReported, ref PlayerState reportingPlayer)
		{
			return true;
		}

		public virtual bool OnVotingBegan(ref PlayerState bodyReported, ref PlayerState reportingPlayer)
		{
			return true;
		}

		public virtual bool OnAllVotesCast()
		{
			return true;
		}

		public virtual bool OnGameStart()
		{
			return true;
		}

		public virtual bool OnBeforeAssignRoles()
		{
			return true;
		}

		public virtual void OnAfterAssignRoles()
		{
		}

		public virtual bool OnGameEnd(ref GameTeam teamThatWon)
		{
			return true;
		}

		public GameRole GetTrueRole(PlayerState player)
		{
			//IL_0034: 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)
			Enumerator<GameRole, List<int>> enumerator = Current.Role.gameRoleToPlayerIds.GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<GameRole, List<int>> current = enumerator.Current;
				Enumerator<int> enumerator2 = current.Value.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					int current2 = enumerator2.Current;
					if (NetworkBool.op_Implicit(player.IsConnected) && current2 == player.PlayerId)
					{
						return current.Key;
					}
				}
			}
			return (GameRole)0;
		}
	}
}
namespace AirlockAPI.Debug
{
	internal static class Logging
	{
		public static void Log(string message)
		{
			((BasePlugin)Loader.Instance).Log.LogInfo((object)message);
		}

		public static void Warn(string message)
		{
			((BasePlugin)Loader.Instance).Log.LogWarning((object)message);
		}

		public static void Error(string message, bool crash = false)
		{
			((BasePlugin)Loader.Instance).Log.LogError((object)message);
			if (crash)
			{
				Application.Quit();
			}
		}

		public static void Debug_Log(string message)
		{
		}

		public static void Debug_Warn(string message)
		{
		}

		public static void Debug_Error(string message)
		{
		}
	}
}
namespace AirlockAPI.Data
{
	public class AirlockEventInfo
	{
		public int code;

		public Hashtable? customData;

		public AirlockEventInfo(int code, Hashtable customData)
		{
			this.code = code;
			this.customData = customData;
		}
	}
	public class AirlockRpcInfo
	{
		public PlayerRef Sender { get; internal set; } = PlayerRef.None;

		public string Rpc { get; internal set; } = "";

		public NetworkManager.RpcTarget Target { get; internal set; }

		public NetworkManager.RpcCaller Caller { get; internal set; }
	}
	public static class CurrentMode
	{
		public static string Name = "";

		public static bool Modded;

		public static bool IsHosting;
	}
	internal static class Info
	{
		public const string Name = "AirlockAPI";

		public const string VersionAPI = "1.0.1";

		public const string Developer = "YouTubey";

		public const string GUID = "com.airlockapi.youtubey";
	}
}
namespace AirlockAPI.Components
{
	public class AirlockNetworkTransform : MonoBehaviour
	{
		private Vector3 oldScale;

		private Quaternion oldRot;

		private Vector3 oldPos;

		[AirlockRpc("INTERNAL_UpdateTransform", NetworkManager.RpcTarget.All, NetworkManager.RpcCaller.Host)]
		internal static void UpdateTransform(GameObject obj, Vector3 pos, Quaternion rot, Vector3 scale)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)obj == (Object)null))
			{
				AirlockNetworkTransform component = obj.GetComponent<AirlockNetworkTransform>();
				if ((Object)(object)component != (Object)null)
				{
					((Component)component).transform.localPosition = pos;
					((Component)component).transform.localRotation = rot;
					((Component)component).transform.localScale = scale;
				}
			}
		}

		private void Update()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: 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_0025: 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_0064: 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_0076: 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_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: 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)
			Vector3 localPosition = ((Component)this).transform.localPosition;
			Quaternion localRotation = ((Component)this).transform.localRotation;
			Vector3 localScale = ((Component)this).transform.localScale;
			if (oldScale != localScale || oldRot != localRotation || oldPos != localPosition)
			{
				NetworkManager.SendRpc("INTERNAL_UpdateTransform", ((Component)this).gameObject, localPosition, localRotation, localScale);
			}
			oldPos = ((Component)this).transform.localPosition;
			oldScale = ((Component)this).transform.localScale;
			oldRot = ((Component)this).transform.localRotation;
		}
	}
	public class AirlockSimulationBehaviour : MonoBehaviour
	{
		internal static List<AirlockSimulationBehaviour> All = new List<AirlockSimulationBehaviour>();

		public virtual void OnEvent(AirlockEventInfo eventInfo)
		{
		}

		public AirlockSimulationBehaviour()
		{
			All.Add(this);
		}

		~AirlockSimulationBehaviour()
		{
			try
			{
				All.Remove(this);
			}
			finally
			{
				((Il2CppObjectBase)this).Finalize();
			}
		}
	}
}
namespace AirlockAPI.Attributes
{
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false)]
	public class AirlockRpc : Attribute
	{
		internal string RpcName;

		internal NetworkManager.RpcTarget RpcTarget;

		internal NetworkManager.RpcCaller RpcCaller;

		public AirlockRpc(string rpcName, NetworkManager.RpcTarget rpcTarget, NetworkManager.RpcCaller rpcCaller)
		{
			RpcName = rpcName;
			RpcTarget = rpcTarget;
			RpcCaller = rpcCaller;
		}

		public override string ToString()
		{
			return $"{RpcName}|{RpcTarget.ToString()}|{RpcCaller.ToString()}";
		}
	}
}