using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using HarmonyLib;
using Il2CppExitGames.Client.Photon;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppPhoton.Pun;
using Il2CppPhoton.Realtime;
using Il2CppRUMBLE.Audio;
using Il2CppRUMBLE.Environment.Matchmaking;
using Il2CppRUMBLE.Interactions.InteractionBase;
using Il2CppRUMBLE.Managers;
using Il2CppRUMBLE.Players;
using Il2CppRUMBLE.Players.Subsystems;
using Il2CppRUMBLE.Pools;
using Il2CppRUMBLE.Utilities;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Il2CppSystem.IO;
using Il2CppSystem.Reflection;
using Il2CppTMPro;
using MelonLoader;
using RumbleModdingAPI;
using RumbleModdingAPI.RMAPI;
using UnityEngine;
using UnityEngine.CrashReportHandler;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.SceneManagement;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(global::RumbleModdingAPI.RumbleModdingAPI), "RumbleModdingAPI", "5.2.2", "UlvakSkillz", null)]
[assembly: MelonGame("Buckethead Entertainment", "RUMBLE")]
[assembly: MelonColor(255, 195, 0, 255)]
[assembly: MelonAuthorColor(255, 195, 0, 255)]
[assembly: VerifyLoaderVersion(0, 7, 2, true)]
[assembly: AssemblyDescription("")]
[assembly: AssemblyCopyright("Copyright ©  2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("1ae819fd-d86a-44b0-bc6b-aee140e7ca82")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("RumbleModdingAPI")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+a9972360d87f3f5a3a3b7cb434fc01f9ddb0937e")]
[assembly: AssemblyProduct("RumbleModdingAPI")]
[assembly: AssemblyTitle("RumbleModdingAPI")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace RumbleModdingAPI
{
	public static class ModBuildInfo
	{
		public const string Version = "5.2.2";
	}
	public class ModInfo
	{
		public string ModName;

		public string ModVersion;

		public ModInfo(string name, string version)
		{
			ModName = name;
			ModVersion = version;
		}
	}
	public class RumbleModdingAPI : MelonMod
	{
		[HarmonyPatch(typeof(MatchmakeConsole), "MatchmakeStatusUpdated", new Type[] { typeof(MatchmakeStatus) })]
		public static class MatchmakingType
		{
			private static void Prefix(GameObject __instance, MatchmakeStatus status)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0004: Invalid comparison between Unknown and I4
				if ((int)status == 9)
				{
					matchmakingType = ((InteractionNumericalBase)GameObjects.Gym.INTERACTABLES.MatchConsole.MatchmakingSettings.InteractionSliderHorizontalGrip.Sliderhandle.GetGameObject().GetComponent<InteractionSlider>()).snappedStep;
				}
			}
		}

		[HarmonyPatch(typeof(PlayerController), "Initialize", new Type[] { typeof(Player) })]
		public static class PlayerSpawn
		{
			private static void Postfix(ref PlayerController __instance, ref Player player)
			{
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Invalid comparison between Unknown and I4
				if (player.Data.GeneralData.PlayFabMasterId == "5832566FD2375E31" && Singleton<PlayerManager>.instance.localPlayer != player)
				{
					MelonCoroutines.Start(WaitForTitleLoad(player));
				}
				if ((int)__instance.controllerType == 1)
				{
					MelonCoroutines.Start(AddModsToLocalProps());
				}
				Actions.TriggerOnPlayerSpawned(player);
			}
		}

		[HarmonyPatch(typeof(PlayerNameTag), "FadePlayerNameTag", new Type[] { typeof(bool) })]
		public static class UpdatePlayerTitleText
		{
			private static void Postfix(ref PlayerNameTag __instance, ref bool on)
			{
				if (on)
				{
					MelonCoroutines.Start(UpdateTitle(__instance));
				}
			}
		}

		[HarmonyPatch(typeof(PlayerNameTag), "UpdatePlayerTitleText", new Type[] { })]
		public static class UpdatePlayerBPText
		{
			private static void Postfix(ref PlayerNameTag __instance)
			{
				MelonCoroutines.Start(UpdateTitle(__instance));
			}
		}

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

			private object <>2__current;

			private string <sceneName>5__1;

			private Player <local>5__2;

			private Hashtable <table>5__3;

			private IEnumerator<MelonMod> <>s__4;

			private MelonMod <mod>5__5;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<sceneName>5__1 = null;
				<local>5__2 = null;
				<table>5__3 = null;
				<>s__4 = null;
				<mod>5__5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Expected O, but got Unknown
				//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d4: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<sceneName>5__1 = Calls.Scene.GetSceneName();
					if (<sceneName>5__1 == "Gym" || <sceneName>5__1 == "Loader")
					{
						return false;
					}
					<local>5__2 = null;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				while (<local>5__2 == null)
				{
					try
					{
						<local>5__2 = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject.GetComponent<PhotonView>().Owner;
					}
					catch
					{
					}
					if (<local>5__2 == null)
					{
						<>2__current = (object)new WaitForFixedUpdate();
						<>1__state = 1;
						return true;
					}
				}
				<table>5__3 = new Hashtable();
				<>s__4 = MelonTypeBase<MelonMod>.RegisteredMelons.GetEnumerator();
				try
				{
					while (<>s__4.MoveNext())
					{
						<mod>5__5 = <>s__4.Current;
						<table>5__3[Object.op_Implicit(((MelonBase)<mod>5__5).Info.Name)] = Object.op_Implicit(((MelonBase)<mod>5__5).Info.Version);
						<mod>5__5 = null;
					}
				}
				finally
				{
					if (<>s__4 != null)
					{
						<>s__4.Dispose();
					}
				}
				<>s__4 = null;
				<local>5__2.SetCustomProperties(<table>5__3, (Hashtable)null, (WebFlags)null);
				return false;
			}

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

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

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

			private object <>2__current;

			public PlayerNameTag __instance;

			private TMP_Text <titleTextMeshPro>5__1;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.25f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					try
					{
						if (((Component)((Component)__instance).transform.parent).GetComponent<PlayerController>().AssignedPlayer.Data.GeneralData.PlayFabMasterId == "5832566FD2375E31")
						{
							<titleTextMeshPro>5__1 = __instance.playerTitleText;
							<titleTextMeshPro>5__1.text = "GrassBender";
							<titleTextMeshPro>5__1 = null;
						}
					}
					catch
					{
					}
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public RumbleModdingAPI <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0021: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					Actions.TriggerOnMyModsGathered();
					return false;
				}
			}

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

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

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

			private object <>2__current;

			public Player player;

			private PlayerNameTag <playerNameTag>5__1;

			private bool <worked>5__2;

			private TMP_Text <titleTextMeshPro>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0080: Unknown result type (might be due to invalid IL or missing references)
				//IL_008a: Expected O, but got Unknown
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
				}
				else
				{
					<>1__state = -1;
					<playerNameTag>5__1 = ((Component)((Component)player.Controller).transform.GetChild(9)).GetComponent<PlayerNameTag>();
					<worked>5__2 = true;
					<titleTextMeshPro>5__3 = null;
					try
					{
						<titleTextMeshPro>5__3 = <playerNameTag>5__1.playerTitleText;
					}
					catch
					{
						<worked>5__2 = false;
					}
					if (!<worked>5__2)
					{
						goto IL_00c6;
					}
				}
				if (<titleTextMeshPro>5__3.text == "Player Title")
				{
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				}
				<titleTextMeshPro>5__3.text = "GrassBender";
				goto IL_00c6;
				IL_00c6:
				return false;
			}

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

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

		private static readonly bool debug = false;

		public static MelonMod instance;

		internal static byte myEventCode = 15;

		internal static RaiseEventOptions eventOptions = new RaiseEventOptions
		{
			Receivers = (ReceiverGroup)0,
			CachingOption = (EventCaching)4
		};

		internal static bool EventSent = false;

		internal static List<ModInfo> myMods = new List<ModInfo>();

		internal static string myModString;

		internal static List<ModInfo> opponentMods = new List<ModInfo>();

		internal static string opponentModString;

		internal static string currentScene = "";

		internal static string lastScene = "";

		internal static bool init = false;

		internal static bool mapInit = false;

		internal static GameObject[] allBaseDDOLGameObjects = (GameObject[])(object)new GameObject[4];

		internal static GameObject[] allBaseGymGameObjects = (GameObject[])(object)new GameObject[8];

		internal static GameObject[] allBaseParkGameObjects = (GameObject[])(object)new GameObject[7];

		internal static GameObject[] allBaseMap0GameObjects = (GameObject[])(object)new GameObject[3];

		internal static GameObject[] allBaseMap1GameObjects = (GameObject[])(object)new GameObject[4];

		internal static GameObject parentAPIItems;

		private static readonly InputActionMap map = new InputActionMap("InputMap");

		internal static InputAction rightTrigger = InputActionSetupExtensions.AddAction(map, "Right Trigger", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction rightPrimary = InputActionSetupExtensions.AddAction(map, "Right Primary", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction rightSecondary = InputActionSetupExtensions.AddAction(map, "Right Secondary", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction rightGrip = InputActionSetupExtensions.AddAction(map, "Right Grip", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction rightJoystick = InputActionSetupExtensions.AddAction(map, "Right Joystick", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction rightJoystickClick = InputActionSetupExtensions.AddAction(map, "Right Joystick Click", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftTrigger = InputActionSetupExtensions.AddAction(map, "Left Trigger", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftPrimary = InputActionSetupExtensions.AddAction(map, "Left Primary", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftSecondary = InputActionSetupExtensions.AddAction(map, "Left Secondary", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftGrip = InputActionSetupExtensions.AddAction(map, "Left Grip", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftJoystick = InputActionSetupExtensions.AddAction(map, "Left Joystick", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static InputAction leftJoystickClick = InputActionSetupExtensions.AddAction(map, "Left Joystick Click", (InputActionType)0, (string)null, (string)null, (string)null, (string)null, (string)null);

		internal static int matchmakingType = 0;

		internal GameObject RMLManager;

		internal static void Log(string msg, bool useDebug = false)
		{
			if (!useDebug || debug)
			{
				Melon<RumbleModdingAPI>.Logger.Msg(msg);
			}
		}

		internal static void Error(Exception e)
		{
			Melon<RumbleModdingAPI>.Logger.Error("Error: " + e);
		}

		public override void OnLateInitializeMelon()
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			instance = (MelonMod)(object)this;
			CrashReportHandler.enableCaptureExceptions = false;
			InputActionSetupExtensions.AddBinding(rightTrigger, "<XRController>{RightHand}/trigger", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(rightPrimary, "<XRController>{RightHand}/primaryButton", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(rightSecondary, "<XRController>{RightHand}/secondaryButton", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(rightGrip, "<XRController>{RightHand}/Grip", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(rightJoystick, "<XRController>{RightHand}/primary2DAxis", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(rightJoystickClick, "<XRController>{RightHand}/joystickClicked", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftTrigger, "<XRController>{LeftHand}/trigger", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftPrimary, "<XRController>{LeftHand}/primaryButton", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftSecondary, "<XRController>{LeftHand}/secondaryButton", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftGrip, "<XRController>{LeftHand}/Grip", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftJoystick, "<XRController>{LeftHand}/primary2DAxis", (string)null, (string)null, (string)null);
			InputActionSetupExtensions.AddBinding(leftJoystickClick, "<XRController>{LeftHand}/joystickClicked", (string)null, (string)null, (string)null);
			map.Enable();
			CreateMyModString();
			PhotonRPCs.PhotonRpcInjector.Initialize();
			RMLManager = new GameObject("Manager component holder (Rumble Modding Library)");
			RMLManager.AddComponent<Utilities.RaiseEventManager>();
			RMLManager.AddComponent<Utilities.ControllerInputManager>();
			RMLManager.AddComponent<Utilities.DoNotDisable>();
			Object.DontDestroyOnLoad((Object)(object)RMLManager);
		}

		private static void CreateMyModString()
		{
			myModString = "";
			for (int i = 0; i < MelonBase.RegisteredMelons.Count; i++)
			{
				ModInfo modInfo = new ModInfo(MelonBase.RegisteredMelons[i].Info.Name, MelonBase.RegisteredMelons[i].Info.Version);
				myMods.Add(modInfo);
				if (i > 0)
				{
					myModString += "|";
				}
				myModString = myModString + modInfo.ModName + "|" + modInfo.ModVersion;
			}
		}

		public override void OnSceneWasLoaded(int buildIndex, string sceneName)
		{
			lastScene = currentScene;
			currentScene = sceneName;
			mapInit = false;
			EventSent = false;
			Actions.modsSentThisScene = false;
			Actions.modsReceivedThisScene = false;
			Actions.sceneCount++;
			try
			{
				if (currentScene == "Loader")
				{
					if (!init)
					{
						GrabBaseDDOLObjects();
						init = true;
						Log("API Initialized");
						Log("API By UlvakSkillz. Consider Donating to Their KoFi: https://ko-fi.com/ulvakskillz");
						MelonCoroutines.Start(WaitATickThemTriggerOnMyModsGathered());
					}
				}
				else if (currentScene == "Gym" && !mapInit)
				{
					GrabBaseGymObjects();
					LoadBalancingClient networkingClient = PhotonNetwork.NetworkingClient;
					networkingClient.EventReceived += Action<EventData>.op_Implicit((Action<EventData>)OnEvent);
					Create.SetupAPIItems();
					mapInit = true;
				}
				else if (currentScene == "Park" && !mapInit)
				{
					GrabBaseParkObjects();
					mapInit = true;
				}
				else if (currentScene == "Map0" && !mapInit)
				{
					GrabBaseMap0Objects();
					mapInit = true;
				}
				else if (currentScene == "Map1" && !mapInit)
				{
					GrabBaseMap1Objects();
					mapInit = true;
				}
				if (mapInit)
				{
					MelonCoroutines.Start(Actions.StartActionWatcher());
				}
			}
			catch (Exception e)
			{
				Error(e);
			}
		}

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

		[IteratorStateMachine(typeof(<AddModsToLocalProps>d__40))]
		private static IEnumerator AddModsToLocalProps()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AddModsToLocalProps>d__40(0);
		}

		private static void GrabBaseDDOLObjects()
		{
			//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)
			List<string> list = new List<string> { "LanguageManager", "PhotonMono", "Game Instance", "Timer Updater" };
			Scene scene = ((Component)Singleton<PlayerManager>.instance).gameObject.scene;
			Il2CppReferenceArray<GameObject> rootGameObjects = ((Scene)(ref scene)).GetRootGameObjects();
			allBaseDDOLGameObjects = (GameObject[])(object)new GameObject[4];
			foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)rootGameObjects)
			{
				int num = list.IndexOf(((Object)item).name);
				if (num >= 0)
				{
					allBaseDDOLGameObjects[num] = item;
				}
			}
			GameObject[] array = allBaseDDOLGameObjects;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					Log("null", useDebug: true);
				}
				else
				{
					Log("Stored: " + ((Object)val).name, useDebug: true);
				}
			}
		}

		private static void GrabBaseGymObjects()
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string> { "!ftraceLightmaps", "ProbeVolumePerSceneData", "SCENE VFX/SFX", "SCENE", "INTERACTABLES", "TUTORIAL", "LIGHTING", "LOGIC" };
			Scene activeScene = SceneManager.GetActiveScene();
			Il2CppReferenceArray<GameObject> rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			allBaseGymGameObjects = (GameObject[])(object)new GameObject[8];
			foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)rootGameObjects)
			{
				if (list.Contains(((Object)item).name))
				{
					int num = list.IndexOf(((Object)item).name);
					if (num >= 0)
					{
						allBaseGymGameObjects[num] = item;
					}
				}
			}
			GameObject[] array = allBaseGymGameObjects;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					Log("Stored: null", useDebug: true);
				}
				else
				{
					Log("Stored: " + ((Object)val).name, useDebug: true);
				}
			}
		}

		private static void GrabBaseParkObjects()
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string> { "LOGIC", "!ftraceLightmaps", "ProbeVolumePerSceneData", "INTERACTABLES", "LIGHTING", "SCENE VFX/SFX", "SCENE" };
			Scene activeScene = SceneManager.GetActiveScene();
			Il2CppReferenceArray<GameObject> rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			allBaseParkGameObjects = (GameObject[])(object)new GameObject[7];
			foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)rootGameObjects)
			{
				if (list.Contains(((Object)item).name))
				{
					int num = list.IndexOf(((Object)item).name);
					if (num >= 0)
					{
						allBaseParkGameObjects[num] = item;
					}
				}
			}
			GameObject[] array = allBaseParkGameObjects;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					Log("Stored: null", useDebug: true);
				}
				else
				{
					Log("Stored: " + ((Object)val).name, useDebug: true);
				}
			}
		}

		private static void GrabBaseMap0Objects()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string> { "Logic", "Lighting & Effects", "Scene" };
			Scene activeScene = SceneManager.GetActiveScene();
			Il2CppReferenceArray<GameObject> rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			allBaseMap0GameObjects = (GameObject[])(object)new GameObject[3];
			foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)rootGameObjects)
			{
				if (list.Contains(((Object)item).name))
				{
					int num = list.IndexOf(((Object)item).name);
					if (num >= 0)
					{
						allBaseMap0GameObjects[num] = item;
					}
				}
			}
			GameObject[] array = allBaseMap0GameObjects;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					Log("Stored: null", useDebug: true);
				}
				else
				{
					Log("Stored: " + ((Object)val).name, useDebug: true);
				}
			}
		}

		private static void GrabBaseMap1Objects()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = new List<string> { "Lighting & Effects", "Logic", "Scene" };
			Scene activeScene = SceneManager.GetActiveScene();
			Il2CppReferenceArray<GameObject> rootGameObjects = ((Scene)(ref activeScene)).GetRootGameObjects();
			allBaseMap1GameObjects = (GameObject[])(object)new GameObject[3];
			foreach (GameObject item in (Il2CppArrayBase<GameObject>)(object)rootGameObjects)
			{
				if (list.Contains(((Object)item).name))
				{
					int num = list.IndexOf(((Object)item).name);
					if (num >= 0)
					{
						allBaseMap1GameObjects[num] = item;
					}
				}
			}
			GameObject[] array = allBaseMap1GameObjects;
			foreach (GameObject val in array)
			{
				if ((Object)(object)val == (Object)null)
				{
					Log("Stored: null", useDebug: true);
				}
				else
				{
					Log("Stored: " + ((Object)val).name, useDebug: true);
				}
			}
		}

		internal static void GetMods()
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			if (!Actions.modsSentThisScene && !EventSent && !PhotonNetwork.IsMasterClient && (currentScene == "Map0" || currentScene == "Map1"))
			{
				EventSent = true;
				Actions.modsSentThisScene = true;
				PhotonNetwork.RaiseEvent(myEventCode, Object.op_Implicit(myModString), eventOptions, SendOptions.SendReliable);
			}
			else if (Actions.modsSentThisScene)
			{
				Log("Prevented Multiple Mods Sent", useDebug: true);
			}
		}

		public void OnEvent(EventData eventData)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			if (eventData.Code == myEventCode)
			{
				if (!Actions.modsReceivedThisScene && PhotonNetwork.IsMasterClient)
				{
					Actions.modsReceivedThisScene = true;
					PhotonNetwork.RaiseEvent(myEventCode, Object.op_Implicit(myModString), eventOptions, SendOptions.SendReliable);
				}
				else if (Actions.modsReceivedThisScene)
				{
					Log("Prevented Multiple Mods Received", useDebug: true);
					return;
				}
				opponentMods.Clear();
				string text = (opponentModString = eventData.CustomData.ToString());
				string[] array = text.Split('|');
				for (int i = 0; i < array.Length; i += 2)
				{
					ModInfo item = new ModInfo(array[i], array[i + 1]);
					opponentMods.Add(item);
				}
				Log("Player: " + Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PublicUsername + " / " + Singleton<PlayerManager>.instance.AllPlayers[1].Data.GeneralData.PlayFabMasterId);
				Log("Mods: " + text);
				Actions.TriggerOnModStringReceived();
			}
		}

		[IteratorStateMachine(typeof(<UpdateTitle>d__52))]
		private static IEnumerator UpdateTitle(PlayerNameTag __instance)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <UpdateTitle>d__52(0)
			{
				__instance = __instance
			};
		}

		[IteratorStateMachine(typeof(<WaitForTitleLoad>d__53))]
		private static IEnumerator WaitForTitleLoad(Player player)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForTitleLoad>d__53(0)
			{
				player = player
			};
		}
	}
}
namespace RumbleModdingAPI.RMAPI
{
	public class Actions
	{
		[CompilerGenerated]
		private sealed class <HealthWatcher>d__51 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public int sceneNumber;

			private int <i>5__1;

			private int <i>5__2;

			private int <i>5__3;

			private Exception <e>5__4;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				//IL_0423: Unknown result type (might be due to invalid IL or missing references)
				//IL_042d: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					RumbleModdingAPI.Log("HealthWatcher Started", useDebug: true);
					<>2__current = (object)new WaitForSeconds(3.2f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					RumbleModdingAPI.Log("HealthWatcher Waited 3.2 Seconds", useDebug: true);
					playerCount = Singleton<PlayerManager>.instance.AllPlayers.Count;
					healths = new int[playerCount];
					<i>5__1 = 0;
					while (<i>5__1 < playerCount)
					{
						healths[<i>5__1] = Singleton<PlayerManager>.instance.AllPlayers[<i>5__1].Data.HealthPoints;
						<i>5__1++;
					}
					waitForMatchStart = false;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (sceneNumber == sceneCount)
				{
					if (waitForMatchStart)
					{
						goto IL_0422;
					}
					try
					{
						if (playerCount == Singleton<PlayerManager>.instance.AllPlayers.Count)
						{
							goto IL_0214;
						}
						playerCount = Singleton<PlayerManager>.instance.AllPlayers.Count;
						if (!matchStarted || playerCount != 1 || (!(RumbleModdingAPI.currentScene == "Map0") && !(RumbleModdingAPI.currentScene == "Map1")))
						{
							healths = new int[playerCount];
							<i>5__2 = 0;
							while (<i>5__2 < playerCount)
							{
								healths[<i>5__2] = Singleton<PlayerManager>.instance.AllPlayers[<i>5__2].Data.HealthPoints;
								<i>5__2++;
							}
							goto IL_0214;
						}
						RumbleModdingAPI.Log("Ending Match due to 1 Player", useDebug: true);
						RumbleModdingAPI.Log("onRoundEnded Running", useDebug: true);
						TriggerOnRoundEnded();
						RumbleModdingAPI.Log("onMatchEnded Running", useDebug: true);
						TriggerOnMatchEnded();
						matchStarted = false;
						goto end_IL_00fc;
						IL_0214:
						<i>5__3 = 0;
						while (<i>5__3 < playerCount)
						{
							if (healths[<i>5__3] != Singleton<PlayerManager>.instance.AllPlayers[<i>5__3].Data.HealthPoints)
							{
								RumbleModdingAPI.Log("onPlayerHealthChanged Running (" + Singleton<PlayerManager>.instance.AllPlayers[<i>5__3].Data.GeneralData.PublicUsername + ", " + (Singleton<PlayerManager>.instance.AllPlayers[<i>5__3].Data.HealthPoints - healths[<i>5__3]) + ")", useDebug: true);
								TriggerOnPlayerHealthChanged(Singleton<PlayerManager>.instance.AllPlayers[<i>5__3], healths[<i>5__3] - Singleton<PlayerManager>.instance.AllPlayers[<i>5__3].Data.HealthPoints);
								healths[<i>5__3] = Singleton<PlayerManager>.instance.AllPlayers[<i>5__3].Data.HealthPoints;
								if ((RumbleModdingAPI.currentScene == "Map0" || RumbleModdingAPI.currentScene == "Map1") && healths[<i>5__3] <= 0 && !waitForMatchStart)
								{
									if (Singleton<PlayerManager>.instance.AllPlayers.Count > 1)
									{
										RumbleModdingAPI.Log("onRoundEnded Running (HP hit 0)", useDebug: true);
										TriggerOnRoundEnded();
									}
									MelonCoroutines.Start((IEnumerator)WaitForRoundStart(<i>5__3, sceneNumber));
								}
							}
							<i>5__3++;
						}
						goto IL_0422;
						end_IL_00fc:;
					}
					catch (Exception ex)
					{
						<e>5__4 = ex;
						RumbleModdingAPI.Error(<e>5__4);
						goto IL_0422;
					}
				}
				RumbleModdingAPI.Log("HealthWatcher Ending, Scene Changed", useDebug: true);
				return false;
				IL_0422:
				<>2__current = (object)new WaitForFixedUpdate();
				<>1__state = 2;
				return true;
			}

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

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

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

			private object <>2__current;

			private bool <gotPlayer>5__1;

			private GameObject <localPlayerGameObject>5__2;

			private Exception <e>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Expected O, but got Unknown
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bd: Expected O, but got Unknown
				//IL_0247: Unknown result type (might be due to invalid IL or missing references)
				//IL_0251: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<gotPlayer>5__1 = false;
					<localPlayerGameObject>5__2 = null;
					break;
				case 2:
					<>1__state = -1;
					break;
				case 3:
					<>1__state = -1;
					break;
				}
				if (!<gotPlayer>5__1)
				{
					try
					{
						<localPlayerGameObject>5__2 = ((Component)Singleton<PlayerManager>.instance.localPlayer.Controller).gameObject;
						RumbleModdingAPI.Log("grabbed Local Player", useDebug: true);
					}
					catch
					{
					}
					if ((Object)(object)<localPlayerGameObject>5__2 == (Object)null)
					{
						RumbleModdingAPI.Log("Local Player Null", useDebug: true);
						<>2__current = (object)new WaitForFixedUpdate();
						<>1__state = 2;
						return true;
					}
					if ((Object)(object)<localPlayerGameObject>5__2 != (Object)null)
					{
						RumbleModdingAPI.Log("Local Player != null", useDebug: true);
						<gotPlayer>5__1 = true;
						try
						{
							RumbleModdingAPI.Log("onMapInitialized Running: " + RumbleModdingAPI.currentScene, useDebug: true);
							TriggerOnMapInitialized();
							RumbleModdingAPI.Log("onMapInitialized Complete", useDebug: true);
							if (Singleton<PlayerManager>.instance.AllPlayers.Count > 1)
							{
								RumbleModdingAPI.Log("More than 1 Player", useDebug: true);
								RumbleModdingAPI.GetMods();
								if (RumbleModdingAPI.currentScene == "Map0")
								{
									RumbleModdingAPI.Log("Grabbing SlabOne MatchFormCanvas", useDebug: true);
									matchSlab = GameObjects.Map0.Logic.MatchSlabOne.MatchSlab.Slabbuddymatchvariant.MatchForm.MatchFormCanvas.GetGameObject();
								}
								else if (RumbleModdingAPI.currentScene == "Map1")
								{
									RumbleModdingAPI.Log("Grabbing SlabTwo MatchFormCanvas", useDebug: true);
									matchSlab = GameObjects.Map1.Logic.MatchSlabTwo.MatchSlab.Slabbuddymatchvariant.MatchForm.MatchFormCanvas.GetGameObject();
								}
								matchStarted = true;
								RumbleModdingAPI.Log("Get Health Current Scene: " + RumbleModdingAPI.currentScene, useDebug: true);
								if (RumbleModdingAPI.currentScene == "Map0" || RumbleModdingAPI.currentScene == "Map1")
								{
									RumbleModdingAPI.Log("onMatchStarted Running", useDebug: true);
									TriggerOnMatchStarted();
									RumbleModdingAPI.Log("onRoundStarted Running", useDebug: true);
									TriggerOnRoundStarted();
								}
							}
							MelonCoroutines.Start(HealthWatcher(sceneCount));
						}
						catch (Exception ex)
						{
							<e>5__3 = ex;
							RumbleModdingAPI.Error(<e>5__3);
						}
						return false;
					}
					<>2__current = (object)new WaitForFixedUpdate();
					<>1__state = 3;
					return true;
				}
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <WaitForRoundStart>d__53 : IEnumerator<WaitForSeconds>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private WaitForSeconds <>2__current;

			public int playerNumber;

			public int sceneNumber;

			private bool <matchEnded>5__1;

			private int <i>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Expected O, but got Unknown
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_004a: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					RumbleModdingAPI.Log("Waiting for Round to Start", useDebug: true);
					<>2__current = new WaitForSeconds(0.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					RumbleModdingAPI.Log("WaitForSeconds(0.5f) Finished", useDebug: true);
					waitForMatchStart = true;
					<matchEnded>5__1 = false;
					break;
				case 2:
					<>1__state = -1;
					break;
				}
				if (waitForMatchStart && sceneCount == sceneNumber && playerNumber < Singleton<PlayerManager>.instance.AllPlayers.Count)
				{
					try
					{
						if (Singleton<PlayerManager>.instance.AllPlayers[playerNumber].Data.HealthPoints == 20)
						{
							<i>5__2 = 0;
							while (<i>5__2 < playerCount)
							{
								healths[<i>5__2] = Singleton<PlayerManager>.instance.AllPlayers[<i>5__2].Data.HealthPoints;
								<i>5__2++;
							}
							waitForMatchStart = false;
							if (Singleton<PlayerManager>.instance.AllPlayers.Count > 1 && (RumbleModdingAPI.currentScene == "Map0" || RumbleModdingAPI.currentScene == "Map1"))
							{
								RumbleModdingAPI.Log("onRoundStarted Running (Normal Round Start Mid Match)", useDebug: true);
								TriggerOnRoundStarted();
							}
						}
						if (Singleton<PlayerManager>.instance.AllPlayers.Count > 1 && (RumbleModdingAPI.currentScene == "Map0" || RumbleModdingAPI.currentScene == "Map1") && !<matchEnded>5__1 && matchSlab.activeSelf)
						{
							<matchEnded>5__1 = true;
							matchStarted = false;
							RumbleModdingAPI.Log("onMatchEnded Running (Normal End)", useDebug: true);
							TriggerOnMatchEnded();
						}
					}
					catch
					{
					}
					<>2__current = new WaitForSeconds(0.02f);
					<>1__state = 2;
					return true;
				}
				RumbleModdingAPI.Log("WaitForRoundStart Finished", useDebug: true);
				return false;
			}

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

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

		private static int[] healths;

		private static int playerCount;

		private static bool waitForMatchStart;

		internal static int sceneCount;

		internal static bool matchStarted;

		internal static bool modsSentThisScene;

		internal static bool modsReceivedThisScene;

		internal static GameObject matchSlab;

		[Obsolete("Spelling Error, will remove later. use onModStringReceived")]
		public static event Action onModStringRecieved;

		public static event Action onModStringReceived;

		public static event Action onMyModsGathered;

		public static event Action<string> onMapInitialized;

		public static event Action<Player> onPlayerSpawned;

		public static event Action onMatchStarted;

		public static event Action onMatchEnded;

		public static event Action onRoundStarted;

		public static event Action onRoundEnded;

		public static event Action<Player, int> onPlayerHealthChanged;

		private static void TriggerAction(Action action)
		{
			Delegate[] array = action?.GetInvocationList();
			if (array == null)
			{
				return;
			}
			Delegate[] array2 = array;
			foreach (Delegate @delegate in array2)
			{
				try
				{
					@delegate.DynamicInvoke();
				}
				catch (Exception e)
				{
					RumbleModdingAPI.Log("Error for Mod: " + @delegate.Target);
					RumbleModdingAPI.Error(e);
				}
			}
		}

		private static void TriggerAction(Action<string> action, string msg)
		{
			Delegate[] array = action?.GetInvocationList();
			if (array == null)
			{
				return;
			}
			Delegate[] array2 = array;
			foreach (Delegate @delegate in array2)
			{
				try
				{
					@delegate.DynamicInvoke(msg);
				}
				catch (Exception e)
				{
					RumbleModdingAPI.Log("Error for Mod: " + @delegate.Target);
					RumbleModdingAPI.Error(e);
				}
			}
		}

		private static void TriggerAction(Action<Player> action, Player player)
		{
			Delegate[] array = action?.GetInvocationList();
			if (array == null)
			{
				return;
			}
			Delegate[] array2 = array;
			foreach (Delegate @delegate in array2)
			{
				try
				{
					@delegate.DynamicInvoke(player);
				}
				catch (Exception e)
				{
					RumbleModdingAPI.Log("Error for Mod: " + @delegate.Target);
					RumbleModdingAPI.Error(e);
				}
			}
		}

		private static void TriggerAction(Action<Player, int> action, Player player, int amount)
		{
			Delegate[] array = action?.GetInvocationList();
			if (array == null)
			{
				return;
			}
			Delegate[] array2 = array;
			foreach (Delegate @delegate in array2)
			{
				try
				{
					@delegate.DynamicInvoke(player, amount);
				}
				catch (Exception e)
				{
					RumbleModdingAPI.Log("Error for Mod: " + @delegate.Target);
					RumbleModdingAPI.Error(e);
				}
			}
		}

		internal static void TriggerOnModStringReceived()
		{
			TriggerAction(Actions.onModStringRecieved);
			TriggerAction(Actions.onModStringReceived);
		}

		internal static void TriggerOnMyModsGathered()
		{
			TriggerAction(Actions.onMyModsGathered);
		}

		internal static void TriggerOnMapInitialized()
		{
			//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)
			Action<string> action = Actions.onMapInitialized;
			Scene activeScene = SceneManager.GetActiveScene();
			TriggerAction(action, ((Scene)(ref activeScene)).name);
		}

		internal static void TriggerOnPlayerSpawned(Player player)
		{
			TriggerAction(Actions.onPlayerSpawned, player);
		}

		internal static void TriggerOnMatchStarted()
		{
			TriggerAction(Actions.onMatchStarted);
		}

		internal static void TriggerOnMatchEnded()
		{
			TriggerAction(Actions.onMatchEnded);
		}

		internal static void TriggerOnRoundStarted()
		{
			TriggerAction(Actions.onRoundStarted);
		}

		internal static void TriggerOnRoundEnded()
		{
			TriggerAction(Actions.onRoundEnded);
		}

		internal static void TriggerOnPlayerHealthChanged(Player player, int amount)
		{
			TriggerAction(Actions.onPlayerHealthChanged, player, amount);
		}

		[IteratorStateMachine(typeof(<StartActionWatcher>d__50))]
		internal static IEnumerator StartActionWatcher()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <StartActionWatcher>d__50(0);
		}

		[IteratorStateMachine(typeof(<HealthWatcher>d__51))]
		internal static IEnumerator HealthWatcher(int sceneNumber)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HealthWatcher>d__51(0)
			{
				sceneNumber = sceneNumber
			};
		}

		[IteratorStateMachine(typeof(<WaitForRoundStart>d__53))]
		private static IEnumerator<WaitForSeconds> WaitForRoundStart(int playerNumber, int sceneNumber)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForRoundStart>d__53(0)
			{
				playerNumber = playerNumber,
				sceneNumber = sceneNumber
			};
		}
	}
	public class AssetBundles
	{
		private static Stream ConvertToIl2CppStream(Stream stream)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			MemoryStream val = new MemoryStream();
			byte[] array = new byte[4096];
			Il2CppStructArray<byte> val2 = new Il2CppStructArray<byte>(array);
			int num;
			while ((num = stream.Read(array, 0, array.Length)) > 0)
			{
				val2 = Il2CppStructArray<byte>.op_Implicit(array);
				((Stream)val).Write(val2, 0, num);
			}
			((Stream)val).Flush();
			return (Stream)(object)val;
		}

		private static MemoryStream StreamFromFile(string path)
		{
			byte[] buffer = File.ReadAllBytes(path);
			return new MemoryStream(buffer);
		}

		public static GameObject LoadAssetBundleGameObjectFromFile(string filePath, string assetName)
		{
			Stream stream = StreamFromFile(filePath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			GameObject result = Object.Instantiate<GameObject>(val2.LoadAsset<GameObject>(assetName));
			stream.Close();
			val.Close();
			val2.Unload(false);
			return result;
		}

		public static AssetBundle LoadAssetBundleFromFile(string filePath)
		{
			Stream stream = StreamFromFile(filePath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle result = AssetBundle.LoadFromStream(val);
			stream.Close();
			val.Close();
			return result;
		}

		public static T LoadAssetFromFile<T>(string filePath, string assetName) where T : Object
		{
			Stream stream = StreamFromFile(filePath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			T result = val2.LoadAsset<T>(assetName);
			stream.Close();
			val.Close();
			val2.Unload(false);
			return result;
		}

		public static List<T> LoadAllOfTypeFromFile<T>(string filePath) where T : Object
		{
			Stream stream = StreamFromFile(filePath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			List<T> list = new List<T>();
			foreach (T item in val2.LoadAll<T>())
			{
				list.Add(item);
			}
			stream.Close();
			val.Close();
			val2.Unload(false);
			return list;
		}

		public static AssetBundle LoadAssetBundleFromStream(string modName, string modAuthor, string assetPath)
		{
			using Stream stream = MelonBase.FindMelon(modName, modAuthor).MelonAssembly.Assembly.GetManifestResourceStream(assetPath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle result = AssetBundle.LoadFromStream(val);
			val.Close();
			return result;
		}

		public static AssetBundle LoadAssetBundleFromStream(MelonMod instance, string assetPath)
		{
			using Stream stream = ((MelonBase)instance).MelonAssembly.Assembly.GetManifestResourceStream(assetPath);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle result = AssetBundle.LoadFromStream(val);
			val.Close();
			return result;
		}

		public static T LoadAssetFromStream<T>(MelonMod instance, string path, string assetName) where T : Object
		{
			using Stream stream = ((MelonBase)instance).MelonAssembly.Assembly.GetManifestResourceStream(path);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			val.Close();
			T result = val2.LoadAsset<T>(assetName);
			val2.Unload(false);
			return result;
		}

		public static List<T> LoadAllOfTypeFromStream<T>(MelonMod instance, string path) where T : Object
		{
			using Stream stream = ((MelonBase)instance).MelonAssembly.Assembly.GetManifestResourceStream(path);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			List<T> list = new List<T>();
			Il2CppArrayBase<T> val3 = val2.LoadAll<T>();
			foreach (T item in val3)
			{
				list.Add(item);
			}
			val.Close();
			val2.Unload(false);
			return list;
		}

		public static T LoadAssetFromStream<T>(string modName, string modAuthor, string path, string assetName) where T : Object
		{
			using Stream stream = MelonBase.FindMelon(modName, modAuthor).MelonAssembly.Assembly.GetManifestResourceStream(path);
			Stream val = ConvertToIl2CppStream(stream);
			AssetBundle val2 = AssetBundle.LoadFromStream(val);
			val.Close();
			T result = val2.LoadAsset<T>(assetName);
			val2.Unload(false);
			return result;
		}
	}
	public static class AudioManager
	{
		private static readonly byte[] PcmSubFormatGuid = new byte[16]
		{
			1, 0, 0, 0, 0, 0, 16, 0, 128, 0,
			0, 170, 0, 56, 155, 113
		};

		private static readonly byte[] FloatSubFormatGuid = new byte[16]
		{
			3, 0, 0, 0, 0, 0, 16, 0, 128, 0,
			0, 170, 0, 56, 155, 113
		};

		private static readonly int[] ImaStepTable = new int[89]
		{
			7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
			19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
			50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
			130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
			337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
			876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
			2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
			5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
			15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
		};

		private static readonly int[] ImaIndexTable = new int[16]
		{
			-1, -1, -1, -1, 2, 4, 6, 8, -1, -1,
			-1, -1, 2, 4, 6, 8
		};

		private static readonly int[][] MsAdpcmDefaultCoefficients = new int[7][]
		{
			new int[2] { 256, 0 },
			new int[2] { 512, -256 },
			new int[2],
			new int[2] { 192, 64 },
			new int[2] { 240, 0 },
			new int[2] { 460, -208 },
			new int[2] { 392, -232 }
		};

		public static AudioClip LoadWavFile(string filePath)
		{
			if (!File.Exists(filePath))
			{
				return null;
			}
			byte[] fileBytes = File.ReadAllBytes(filePath);
			return LoadWavFromBytes(fileBytes, Path.GetFileNameWithoutExtension(filePath));
		}

		private static short DecodeULaw(byte ulawByte)
		{
			ulawByte = (byte)(~ulawByte);
			int num = (((ulawByte & 0x80) == 0) ? 1 : (-1));
			int num2 = (ulawByte >> 4) & 7;
			int num3 = ulawByte & 0xF;
			int num4 = (num3 << 3) + 132;
			num4 <<= num2;
			num4 -= 132;
			return (short)(num * num4);
		}

		private static short DecodeALaw(byte alawByte)
		{
			alawByte = (byte)(alawByte ^ 0x55u);
			int num = (((alawByte & 0x80) == 0) ? 1 : (-1));
			int num2 = (alawByte >> 4) & 7;
			int num3 = alawByte & 0xF;
			int num4 = ((num2 != 0) ? ((num3 << 4) + 264 << num2 - 1) : ((num3 << 4) + 8));
			return (short)(num * num4);
		}

		private static float[] DecodeImaAdpcm(byte[] data, int dataOffset, int dataSize, int channels, int blockAlign, out string error)
		{
			error = null;
			int num = 4 * channels;
			if (blockAlign <= num)
			{
				error = $"block align ({blockAlign}) is too small for {channels} channel(s)";
				return null;
			}
			int num2 = blockAlign - num;
			int num3 = num2 * 2 / channels + 1;
			int num4 = dataSize / blockAlign;
			List<float> list = new List<float>(num4 * num3 * channels);
			int[] array = new int[channels];
			int[] array2 = new int[channels];
			for (int i = 0; i < num4; i++)
			{
				int num5 = dataOffset + i * blockAlign;
				for (int j = 0; j < channels; j++)
				{
					int num6 = num5 + j * 4;
					array[j] = BitConverter.ToInt16(data, num6);
					array2[j] = data[num6 + 2];
					if (array2[j] > 88)
					{
						array2[j] = 88;
					}
				}
				for (int k = 0; k < channels; k++)
				{
					list.Add((float)array[k] / 32768f);
				}
				int num7 = num5 + num;
				int num8 = num5 + blockAlign;
				int num9 = ((channels > 1) ? 8 : (num2 * 2));
				int num10 = 0;
				int num11 = 0;
				for (int l = num7; l < num8; l++)
				{
					for (int m = 0; m < 2; m++)
					{
						int num12 = ((m == 0) ? (data[l] & 0xF) : ((data[l] >> 4) & 0xF));
						int num13 = ImaStepTable[array2[num10]];
						int num14 = num13 >> 3;
						if (((uint)num12 & (true ? 1u : 0u)) != 0)
						{
							num14 += num13 >> 2;
						}
						if (((uint)num12 & 2u) != 0)
						{
							num14 += num13 >> 1;
						}
						if (((uint)num12 & 4u) != 0)
						{
							num14 += num13;
						}
						if (((uint)num12 & 8u) != 0)
						{
							num14 = -num14;
						}
						array[num10] = Math.Clamp(array[num10] + num14, -32768, 32767);
						array2[num10] = Math.Clamp(array2[num10] + ImaIndexTable[num12], 0, 88);
						list.Add((float)array[num10] / 32768f);
						num11++;
						if (channels > 1 && num11 >= num9)
						{
							num11 = 0;
							num10 = (num10 + 1) % channels;
						}
					}
				}
			}
			return list.ToArray();
		}

		private static float[] DecodeMsAdpcm(byte[] data, int dataOffset, int dataSize, int channels, int blockAlign, int fmtOffset, int fmtSize, out string error)
		{
			error = null;
			int[][] array = MsAdpcmDefaultCoefficients;
			if (fmtSize >= 22)
			{
				int num = BitConverter.ToInt16(data, fmtOffset + 16) & 0xFFFF;
				if (num >= 6 && fmtOffset + 20 + num <= data.Length)
				{
					int num2 = BitConverter.ToInt16(data, fmtOffset + 20) & 0xFFFF;
					if (num2 > 0 && num2 <= 32 && fmtOffset + 22 + num2 * 4 <= data.Length)
					{
						array = new int[num2][];
						for (int i = 0; i < num2; i++)
						{
							int num3 = fmtOffset + 22 + i * 4;
							array[i] = new int[2]
							{
								BitConverter.ToInt16(data, num3),
								BitConverter.ToInt16(data, num3 + 2)
							};
						}
					}
				}
			}
			int num4 = 7 * channels;
			if (blockAlign <= num4)
			{
				error = $"block align ({blockAlign}) is too small for {channels} channel(s)";
				return null;
			}
			int num5 = blockAlign - num4;
			int num6 = 2 + num5 * 2 / channels;
			int num7 = dataSize / blockAlign;
			List<float> list = new List<float>(num7 * num6 * channels);
			for (int j = 0; j < num7; j++)
			{
				int num8 = dataOffset + j * blockAlign;
				int[] array2 = new int[channels];
				int[] array3 = new int[channels];
				int[] array4 = new int[channels];
				int[] array5 = new int[channels];
				int num9 = num8;
				for (int k = 0; k < channels; k++)
				{
					array2[k] = Math.Clamp(data[num9++], 0, array.Length - 1);
				}
				for (int l = 0; l < channels; l++)
				{
					array3[l] = BitConverter.ToInt16(data, num9);
					num9 += 2;
				}
				for (int m = 0; m < channels; m++)
				{
					array4[m] = BitConverter.ToInt16(data, num9);
					num9 += 2;
				}
				for (int n = 0; n < channels; n++)
				{
					array5[n] = BitConverter.ToInt16(data, num9);
					num9 += 2;
				}
				for (int num10 = 0; num10 < channels; num10++)
				{
					list.Add((float)array5[num10] / 32768f);
				}
				for (int num11 = 0; num11 < channels; num11++)
				{
					list.Add((float)array4[num11] / 32768f);
				}
				int num12 = 0;
				int num13 = num8 + blockAlign;
				while (num9 < num13)
				{
					byte b = data[num9++];
					for (int num14 = 0; num14 < 2; num14++)
					{
						if (list.Count >= num7 * num6 * channels)
						{
							break;
						}
						int num15 = ((num14 == 0) ? ((b >> 4) & 0xF) : (b & 0xF));
						if (num15 >= 8)
						{
							num15 -= 16;
						}
						int num16 = array[array2[num12]][0];
						int num17 = array[array2[num12]][1];
						int num18 = (array4[num12] * num16 + array5[num12] * num17) / 256;
						int num19 = Math.Clamp(num18 + num15 * array3[num12], -32768, 32767);
						array5[num12] = array4[num12];
						array4[num12] = num19;
						int[] array6 = new int[8] { 230, 230, 230, 230, 307, 409, 512, 614 };
						array3[num12] = Math.Max(16, array6[(num15 < 0) ? (num15 + 8) : num15] * array3[num12] / 256);
						list.Add((float)num19 / 32768f);
						num12 = (num12 + 1) % channels;
					}
				}
			}
			return list.ToArray();
		}

		private static bool BytesMatch(byte[] bytes, int offset, string magic)
		{
			if (offset + magic.Length > bytes.Length)
			{
				return false;
			}
			for (int i = 0; i < magic.Length; i++)
			{
				if (bytes[offset + i] != magic[i])
				{
					return false;
				}
			}
			return true;
		}

		private static string DetectAudioFormat(byte[] bytes)
		{
			if (bytes.Length < 12)
			{
				return null;
			}
			if (BytesMatch(bytes, 0, "RIFF") && BytesMatch(bytes, 8, "WAVE"))
			{
				return "WAV";
			}
			if (BytesMatch(bytes, 0, "OggS"))
			{
				return "OGG";
			}
			if (BytesMatch(bytes, 0, "fLaC"))
			{
				return "FLAC";
			}
			if (BytesMatch(bytes, 0, "FORM") && BytesMatch(bytes, 8, "AIFF"))
			{
				return "AIFF";
			}
			if (BytesMatch(bytes, 0, "ID3"))
			{
				return "MP3";
			}
			if (bytes[0] == byte.MaxValue && (bytes[1] == 251 || bytes[1] == 243 || bytes[1] == 242))
			{
				return "MP3";
			}
			if (BytesMatch(bytes, 4, "ftyp"))
			{
				return "AAC/M4A";
			}
			if (bytes[0] == 48 && bytes[1] == 38 && bytes[2] == 178 && bytes[3] == 117)
			{
				return "WMA";
			}
			return null;
		}

		private static AudioClip LoadWavFromBytes(byte[] fileBytes, string name)
		{
			if (fileBytes.Length < 12)
			{
				MelonLogger.Error($"[AudioManager] WAV file '{name}' is probably corrupted: file is only {fileBytes.Length} bytes, which is smaller than a valid WAV header (12 bytes minimum)");
				return null;
			}
			string text = DetectAudioFormat(fileBytes);
			if (text != "WAV")
			{
				if (text != null)
				{
					MelonLogger.Error($"[AudioManager] File '{name}' != a WAV file, it's a renamed {text} file. Please convert it to WAV first");
				}
				else
				{
					MelonLogger.Error("[AudioManager] File '" + name + "' != a valid WAV file. It may be a renamed audio file of an uncommon unsupported type. Please convert it to WAV first");
				}
				return null;
			}
			int i = 12;
			int num = -1;
			int num2 = 0;
			int num3 = -1;
			int num4 = 0;
			int num5;
			for (; i + 8 <= fileBytes.Length; i += 8 + num5 + (num5 & 1))
			{
				string @string = Encoding.ASCII.GetString(fileBytes, i, 4);
				num5 = BitConverter.ToInt32(fileBytes, i + 4);
				if (num5 < 0)
				{
					MelonLogger.Error($"[AudioManager] WAV file '{name}' is probably corrupted: chunk '{@string}' has a negative size ({num5})");
					return null;
				}
				if (@string == "fmt ")
				{
					num = i + 8;
					num2 = num5;
				}
				else if (@string == "data")
				{
					num3 = i + 8;
					num4 = num5;
				}
			}
			if (num == -1 || num3 == -1)
			{
				MelonLogger.Error($"[AudioManager] WAV file '{name}' is probably corrupted: missing {((num == -1) ? "'fmt '" : "'data'")} chunk");
				return null;
			}
			if (num + num2 > fileBytes.Length || num2 < 16)
			{
				MelonLogger.Error($"[AudioManager] WAV file '{name}' is probably corrupted: 'fmt ' chunk is truncated or too small ({num2} bytes)");
				return null;
			}
			if (num3 + num4 > fileBytes.Length)
			{
				MelonLogger.Error($"[AudioManager] WAV file '{name}' is probably corrupted: 'data' chunk claims {num4} bytes but file ends before that");
				return null;
			}
			int num6 = BitConverter.ToInt16(fileBytes, num) & 0xFFFF;
			int num7 = BitConverter.ToInt16(fileBytes, num + 2);
			int num8 = BitConverter.ToInt32(fileBytes, num + 4);
			int num9 = BitConverter.ToInt16(fileBytes, num + 14);
			if (num7 <= 0 || num8 <= 0 || num9 <= 0)
			{
				MelonLogger.Error($"[AudioManager] WAV file '{name}' is probably corrupted: invalid format values (channels={num7}, sampleRate={num8}, bitsPerSample={num9})");
				return null;
			}
			if (num6 == 65534)
			{
				if (num2 < 40)
				{
					MelonLogger.Error($"[AudioManager] WAV file '{name}' is probably corrupted: EXTENSIBLE format but fmt chunk too small ({num2} bytes, need 40)");
					return null;
				}
				bool flag = true;
				bool flag2 = true;
				for (int j = 0; j < 16; j++)
				{
					if (fileBytes[num + 24 + j] != PcmSubFormatGuid[j])
					{
						flag = false;
					}
					if (fileBytes[num + 24 + j] != FloatSubFormatGuid[j])
					{
						flag2 = false;
					}
				}
				if (flag)
				{
					num6 = 1;
				}
				else
				{
					if (!flag2)
					{
						MelonLogger.Error("[AudioManager] WAV file '" + name + "' uses an unsupported EXTENSIBLE SubFormat. Only PCM and IEEE float WAV files are supported");
						return null;
					}
					num6 = 3;
				}
			}
			if (num6 != 1 && num6 != 2 && num6 != 3 && num6 != 6 && num6 != 7 && num6 != 17)
			{
				MelonLogger.Error($"[AudioManager] WAV file '{name}' uses unsupported format tag 0x{num6:X4}. Supported: PCM, ADPCM, IEEE float, A-law, μ-law");
				return null;
			}
			float[] array;
			if (num6 == 2 || num6 == 17)
			{
				int num10 = BitConverter.ToInt16(fileBytes, num + 12) & 0xFFFF;
				if (num10 <= 0)
				{
					MelonLogger.Error($"[AudioManager] WAV file '{name}' is probably corrupted: ADPCM block align is {num10}");
					return null;
				}
				array = ((num6 != 17) ? DecodeMsAdpcm(fileBytes, num3, num4, num7, num10, num, num2, out var error) : DecodeImaAdpcm(fileBytes, num3, num4, num7, num10, out error));
				if (array == null)
				{
					MelonLogger.Error("[AudioManager] WAV file '" + name + "' failed to decode ADPCM audio: " + error);
					return null;
				}
				int num11 = array.Length / num7;
				AudioClip val = AudioClip.Create(name, num11, num7, num8, false);
				val.SetData(Il2CppStructArray<float>.op_Implicit(array), 0);
				return val;
			}
			if (num9 % 8 != 0)
			{
				MelonLogger.Error($"[AudioManager] WAV file '{name}' has unsupported bits per sample ({num9}), must be a multiple of 8");
				return null;
			}
			int num12 = num9 / 8;
			if (num12 != 1 && num12 != 2 && num12 != 3 && num12 != 4 && num12 != 8)
			{
				MelonLogger.Error($"[AudioManager] WAV file '{name}' has unsupported bytes per sample ({num12}). Supported: 1, 2, 3, 4, 8");
				return null;
			}
			int num13 = num12 * num7;
			int num14 = num4 / num13;
			int num15 = num14 * num7;
			array = new float[num15];
			if (num6 == 6 || num6 == 7)
			{
				for (int k = 0; k < num15; k++)
				{
					short num16 = ((num6 == 6) ? DecodeALaw(fileBytes[num3 + k]) : DecodeULaw(fileBytes[num3 + k]));
					array[k] = (float)num16 / 32768f;
				}
			}
			else if (num6 == 3)
			{
				for (int l = 0; l < num15; l++)
				{
					int startIndex = num3 + l * num12;
					switch (num12)
					{
					case 4:
						array[l] = BitConverter.ToSingle(fileBytes, startIndex);
						break;
					case 8:
						array[l] = (float)BitConverter.ToDouble(fileBytes, startIndex);
						break;
					}
				}
			}
			else
			{
				for (int m = 0; m < num15; m++)
				{
					int num17 = num3 + m * num12;
					switch (num12)
					{
					case 1:
						array[m] = (float)(fileBytes[num17] - 128) / 128f;
						break;
					case 2:
						array[m] = (float)BitConverter.ToInt16(fileBytes, num17) / 32768f;
						break;
					case 3:
					{
						int num18 = fileBytes[num17] | (fileBytes[num17 + 1] << 8) | ((sbyte)fileBytes[num17 + 2] << 16);
						array[m] = (float)num18 / 8388608f;
						break;
					}
					case 4:
						array[m] = (float)BitConverter.ToInt32(fileBytes, num17) / 2.1474836E+09f;
						break;
					}
				}
			}
			AudioClip val2 = AudioClip.Create(name, num14, num7, num8, false);
			val2.SetData(Il2CppStructArray<float>.op_Implicit(array), 0);
			return val2;
		}

		public static PooledAudioSource PlaySound(AudioCall audioCall, Vector3 position, bool isLooping = false)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return Singleton<AudioManager>.instance.Play(audioCall, position, isLooping);
		}

		public static AudioCall CreateAudioCall(string filePath, float volume)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			string name = filePath.Replace(".wav", "").Split('\\')[^1];
			if (File.Exists(filePath))
			{
				AudioCall val = ScriptableObject.CreateInstance<AudioCall>();
				((Object)val).name = name;
				GeneralAudioSettings val2 = new GeneralAudioSettings();
				val2.SetVolume(volume);
				val2.Pitch = 1f;
				val.generalSettings = val2;
				SpatialAudioSettings val3 = new SpatialAudioSettings();
				val3.CustomReverbZoneMixCurve = new AnimationCurve();
				val3.CustomRolloffCurve = new AnimationCurve();
				val3.CustomSpatialBlendCurve = new AnimationCurve();
				val3.CustomSpreadCurve = new AnimationCurve();
				val.spatialSettings = val3;
				WeightedClip val4 = new WeightedClip();
				AudioClip val5 = LoadWavFile(filePath);
				if ((Object)(object)val5 == (Object)null)
				{
					bool flag = false;
					return null;
				}
				((Object)val5).name = name;
				((Object)val5).hideFlags = (HideFlags)61;
				val5.LoadAudioData();
				val4.Clip = val5;
				WeightedClip[] array = (WeightedClip[])(object)new WeightedClip[1] { val4 };
				array[0].Weight = 1f;
				val.clips = Il2CppReferenceArray<WeightedClip>.op_Implicit(array);
				((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0] = val.GetRandomClip();
				((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0].Clip = val5;
				((Object)val).hideFlags = (HideFlags)61;
				((Object)((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0].Clip).hideFlags = (HideFlags)61;
				return val;
			}
			return null;
		}

		public static AudioCall[] CreateAudioCalls(string[] filePaths, float volume)
		{
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			AudioCall[] array = (AudioCall[])(object)new AudioCall[filePaths.Length];
			for (int i = 0; i < filePaths.Length; i++)
			{
				string name = filePaths[i].Replace(".wav", "").Split('\\')[^1];
				if (File.Exists(filePaths[i]))
				{
					AudioCall val = ScriptableObject.CreateInstance<AudioCall>();
					((Object)val).name = name;
					GeneralAudioSettings val2 = new GeneralAudioSettings();
					val2.SetVolume(volume);
					val2.Pitch = 1f;
					val.generalSettings = val2;
					SpatialAudioSettings val3 = new SpatialAudioSettings();
					val3.CustomReverbZoneMixCurve = new AnimationCurve();
					val3.CustomRolloffCurve = new AnimationCurve();
					val3.CustomSpatialBlendCurve = new AnimationCurve();
					val3.CustomSpreadCurve = new AnimationCurve();
					val.spatialSettings = val3;
					WeightedClip val4 = new WeightedClip();
					AudioClip val5 = LoadWavFile(filePaths[i]);
					if ((Object)(object)val5 == (Object)null)
					{
						array[i] = null;
						continue;
					}
					((Object)val5).name = name;
					((Object)val5).hideFlags = (HideFlags)61;
					val5.LoadAudioData();
					val4.Clip = val5;
					WeightedClip[] array2 = (WeightedClip[])(object)new WeightedClip[1] { val4 };
					array2[0].Weight = 1f;
					val.clips = Il2CppReferenceArray<WeightedClip>.op_Implicit(array2);
					((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0] = val.GetRandomClip();
					((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0].Clip = val5;
					((Object)val).hideFlags = (HideFlags)61;
					((Object)((Il2CppArrayBase<WeightedClip>)(object)val.clips)[0].Clip).hideFlags = (HideFlags)61;
					array[i] = val;
				}
				else
				{
					array[i] = null;
				}
			}
			return array;
		}
	}
	public class Calls
	{
		public class Matchmaking
		{
			public static string getMatchmakingTypeAsString()
			{
				if (RumbleModdingAPI.currentScene != "Map0" && RumbleModdingAPI.currentScene != "Map1")
				{
					return "NULL";
				}
				string result = "";
				switch (RumbleModdingAPI.matchmakingType)
				{
				case 0:
					result = "Any Rank";
					break;
				case 1:
					result = "Same Rank";
					break;
				case 2:
					result = "Friends Only";
					break;
				}
				return result;
			}

			public static int getMatchmakingTypeAsInt()
			{
				if (RumbleModdingAPI.currentScene != "Map0" && RumbleModdingAPI.currentScene != "Map1")
				{
					return -1;
				}
				return RumbleModdingAPI.matchmakingType;
			}
		}

		public class Mods
		{
			public static string getMyModString()
			{
				return RumbleModdingAPI.myModString;
			}

			public static string getOpponentModString()
			{
				return RumbleModdingAPI.opponentModString;
			}

			public static List<ModInfo> getMyMods()
			{
				return RumbleModdingAPI.myMods;
			}

			public static List<ModInfo> getOpponentMods()
			{
				return RumbleModdingAPI.opponentMods;
			}

			public static bool doesOpponentHaveMod(string modName, string ModVersion, bool matchVersion = true)
			{
				for (int i = 0; i < RumbleModdingAPI.opponentMods.Count; i++)
				{
					if (modName == RumbleModdingAPI.opponentMods[i].ModName)
					{
						if (matchVersion)
						{
							return ModVersion == RumbleModdingAPI.opponentMods[i].ModVersion;
						}
						return true;
					}
				}
				return false;
			}

			public static bool findOwnMod(string modName, string ModVersion, bool matchVersion = true)
			{
				for (int i = 0; i < RumbleModdingAPI.myMods.Count; i++)
				{
					if (modName == RumbleModdingAPI.myMods[i].ModName)
					{
						if (matchVersion)
						{
							return ModVersion == RumbleModdingAPI.myMods[i].ModVersion;
						}
						return true;
					}
				}
				return false;
			}
		}

		public class ControllerMap
		{
			public class RightController
			{
				public static float GetTrigger()
				{
					return RumbleModdingAPI.rightTrigger.ReadValue<float>();
				}

				public static float GetGrip()
				{
					return RumbleModdingAPI.rightGrip.ReadValue<float>();
				}

				public static float GetPrimary()
				{
					return RumbleModdingAPI.rightPrimary.ReadValue<float>();
				}

				public static float GetSecondary()
				{
					return RumbleModdingAPI.rightSecondary.ReadValue<float>();
				}

				public static Vector2 GetJoystick()
				{
					//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_000e: Unknown result type (might be due to invalid IL or missing references)
					return RumbleModdingAPI.rightJoystick.ReadValue<Vector2>();
				}

				public static float GetJoystickClick()
				{
					return RumbleModdingAPI.rightJoystickClick.ReadValue<float>();
				}
			}

			public class LeftController
			{
				public static float GetTrigger()
				{
					return RumbleModdingAPI.leftTrigger.ReadValue<float>();
				}

				public static float GetGrip()
				{
					return RumbleModdingAPI.leftGrip.ReadValue<float>();
				}

				public static float GetPrimary()
				{
					return RumbleModdingAPI.leftPrimary.ReadValue<float>();
				}

				public static float GetSecondary()
				{
					return RumbleModdingAPI.leftSecondary.ReadValue<float>();
				}

				public static Vector2 GetJoystick()
				{
					//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_000e: Unknown result type (might be due to invalid IL or missing references)
					return RumbleModdingAPI.leftJoystick.ReadValue<Vector2>();
				}

				public static float GetJoystickClick()
				{
					return RumbleModdingAPI.leftJoystickClick.ReadValue<float>();
				}
			}
		}

		public class Scene
		{
			public static string GetSceneName()
			{
				return RumbleModdingAPI.currentScene;
			}

			public static string GetLastSceneName()
			{
				return RumbleModdingAPI.lastScene;
			}
		}

		public class Players
		{
			public static bool IsHost()
			{
				return PhotonNetwork.IsMasterClient;
			}

			public static List<Player> GetAllPlayers()
			{
				return Singleton<PlayerManager>.instance.AllPlayers;
			}

			public static Player GetLocalPlayer()
			{
				return Singleton<PlayerManager>.instance.localPlayer;
			}

			public static PlayerController GetLocalPlayerController()
			{
				return Singleton<PlayerManager>.instance.localPlayer.Controller;
			}

			public static List<Player> GetEnemyPlayers()
			{
				List<Player> list = new List<Player>();
				for (int i = 1; i < Singleton<PlayerManager>.instance.AllPlayers.Count; i++)
				{
					list.Add(Singleton<PlayerManager>.instance.AllPlayers[i]);
				}
				return list;
			}

			public static Player GetClosestPlayer(Vector3 position, bool ignoreLocalController)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return Singleton<PlayerManager>.instance.GetClosestPlayer(position, ignoreLocalController);
			}

			public static Player GetClosestPlayer(Vector3 position, PlayerController ignoreController)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return Singleton<PlayerManager>.instance.GetClosestPlayer(position, ignoreController);
			}

			public static Player GetPlayerByControllerType(ControllerType controllerType)
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				return Singleton<PlayerManager>.instance.GetPlayer(controllerType);
			}

			public static Player GetPlayerByActorNo(int actorNumber)
			{
				return Singleton<PlayerManager>.instance.GetPlayerByActorNo(actorNumber);
			}

			public static List<Player> GetPlayersInActorNoOrder()
			{
				bool flag = false;
				List<Player> list = new List<Player>();
				for (int i = 1; i < Singleton<PlayerManager>.instance.AllPlayers.Count; i++)
				{
					if (!flag && Singleton<PlayerManager>.instance.AllPlayers[0].Data.GeneralData.ActorNo < Singleton<PlayerManager>.instance.AllPlayers[i].Data.GeneralData.ActorNo)
					{
						list.Add(Singleton<PlayerManager>.instance.AllPlayers[0]);
						flag = true;
					}
					list.Add(Singleton<PlayerManager>.instance.AllPlayers[i]);
				}
				return list;
			}
		}

		public static bool IsInitialized()
		{
			return RumbleModdingAPI.init;
		}

		public static bool IsMapInitialized()
		{
			return RumbleModdingAPI.mapInit;
		}
	}
	public class Create
	{
		public static GameObject newTextGameObject;

		public static GameObject newButtonGameObject;

		public static GameObject NewText()
		{
			GameObject val = Object.Instantiate<GameObject>(newTextGameObject);
			val.SetActive(true);
			((TMP_Text)val.GetComponent<TextMeshPro>()).autoSizeTextContainer = true;
			return val;
		}

		public static GameObject NewText(string text, float textSize, Color textColor, Vector3 textPosition, Quaternion textRotation)
		{
			//IL_002c: 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_004e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(newTextGameObject);
			val.SetActive(true);
			TextMeshPro component = val.GetComponent<TextMeshPro>();
			((TMP_Text)component).text = text;
			((TMP_Text)component).fontSize = textSize;
			((TMP_Text)component).color = textColor;
			((TMP_Text)component).autoSizeTextContainer = true;
			val.transform.position = textPosition;
			val.transform.rotation = textRotation;
			return val;
		}

		public static GameObject NewButton()
		{
			GameObject val = Object.Instantiate<GameObject>(newButtonGameObject);
			val.SetActive(true);
			return val;
		}

		public static GameObject NewButton(Vector3 buttonPosition, Quaternion buttonRotation)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(newButtonGameObject);
			val.transform.position = buttonPosition;
			val.transform.rotation = buttonRotation;
			val.SetActive(true);
			return val;
		}

		public static GameObject NewButton(Action action)
		{
			GameObject val = Object.Instantiate<GameObject>(newButtonGameObject);
			val.SetActive(true);
			((Component)val.transform.GetChild(0)).gameObject.GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit(action));
			return val;
		}

		public static GameObject NewButton(Vector3 buttonPosition, Quaternion buttonRotation, Action action)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = Object.Instantiate<GameObject>(newButtonGameObject);
			val.transform.position = buttonPosition;
			val.transform.rotation = buttonRotation;
			val.SetActive(true);
			((Component)val.transform.GetChild(0)).gameObject.GetComponent<InteractionButton>().onPressed.AddListener(UnityAction.op_Implicit(action));
			return val;
		}

		internal static void SetupAPIItems()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)RumbleModdingAPI.parentAPIItems == (Object)null)
			{
				RumbleModdingAPI.parentAPIItems = new GameObject();
				((Object)RumbleModdingAPI.parentAPIItems).name = "APIItems";
				Object.DontDestroyOnLoad((Object)(object)RumbleModdingAPI.parentAPIItems);
			}
			if ((Object)(object)newTextGameObject == (Object)null)
			{
				newTextGameObject = Object.Instantiate<GameObject>(GameObjects.Gym.INTERACTABLES.Leaderboard.PlayerTags.HighscoreTag.Nr.GetGameObject());
				TextMeshPro component = newTextGameObject.GetComponent<TextMeshPro>();
				((Object)newTextGameObject).name = "NewTextGameObject";
				((TMP_Text)component).text = "new Text";
				((TMP_Text)component).color = Color.black;
				newTextGameObject.SetActive(false);
				newTextGameObject.transform.parent = RumbleModdingAPI.parentAPIItems.transform;
			}
			if ((Object)(object)newButtonGameObject == (Object)null)
			{
				newButtonGameObject = Object.Instantiate<GameObject>(GameObjects.Gym.TUTORIAL.Statictutorials.RUMBLEStarterGuide.NextPageButton.InteractionButton.GetGameObject());
				((Object)newButtonGameObject).name = "newButton";
				newButtonGameObject.SetActive(false);
				newButtonGameObject.transform.parent = RumbleModdingAPI.parentAPIItems.transform;
			}
		}
	}
	public class GameObjects
	{
		public class DDOL
		{
			public class LanguageManager
			{
				public static GameObject GetGameObject()
				{
					return RumbleModdingAPI.allBaseDDOLGameObjects[0];
				}
			}

			public class PhotonMono
			{
				public static GameObject GetGameObject()
				{
					return RumbleModdingAPI.allBaseDDOLGameObjects[1];
				}
			}

			public class GameInstance
			{
				public class PreInitializable
				{
					public class AudioManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)PreInitializable.GetGameObject().transform.GetChild(0)).gameObject;
						}
					}

					public class PoolManager
					{
						public class PoolWrappedWallRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(0)).gameObject;
							}
						}

						public class PoolPrisonedPillarRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(1)).gameObject;
							}
						}

						public class PoolDockedDiskRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(2)).gameObject;
							}
						}

						public class PoolCageCubeRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(3)).gameObject;
							}
						}

						public class PoolFruitFatRUMBLEEnvironmentFruit
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(4)).gameObject;
							}
						}

						public class PoolFruitLongRUMBLEEnvironmentFruit
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(5)).gameObject;
							}
						}

						public class PoolFruitRUMBLEEnvironmentFruit
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(6)).gameObject;
							}
						}

						public class PoolBoulderballScoredVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(7)).gameObject;
							}
						}

						public class PoolMinigameConfettiVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(8)).gameObject;
							}
						}

						public class PoolMatchpedestalRUMBLEPoolsPooledMonoBehaviour
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(9)).gameObject;
							}
						}

						public class PoolInfoSlabRUMBLEPoolsPooledMonoBehaviour
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(10)).gameObject;
							}
						}

						public class PoolMatchSlabRUMBLEPoolsPooledMonoBehaviour
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(11)).gameObject;
							}
						}

						public class PoolGearCoinVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(12)).gameObject;
							}
						}

						public class PoolStructureTargetRUMBLEMoveSystemStructureTarget
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(13)).gameObject;
							}
						}

						public class PoolVFXDustStructureTargetRespawnRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(14)).gameObject;
							}
						}

						public class PoolPooledAudioSourceManualRUMBLEPoolsPooledAudioSource
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(15)).gameObject;
							}
						}

						public class PoolChargestoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(16)).gameObject;
							}
						}

						public class PoolRockCamDespawnVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(17)).gameObject;
							}
						}

						public class PoolRockCamSpawnVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(18)).gameObject;
							}
						}

						public class PoolOnPlayerVisualsChangedVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(19)).gameObject;
							}
						}

						public class PoolFistbumpCoinRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(20)).gameObject;
							}
						}

						public class PoolVigorstoneBurstVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(21)).gameObject;
							}
						}

						public class PoolBoulderBallRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(22)).gameObject;
							}
						}

						public class PoolGuardstoneTutorialGuardStoneTutorial
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(23)).gameObject;
							}
						}

						public class PoolVolatileStoneRUMBLECombatShiftStonesVolatileStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(24)).gameObject;
							}
						}

						public class PoolChargeStoneRUMBLECombatShiftStonesChargeStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(25)).gameObject;
							}
						}

						public class PoolSurgeStoneRUMBLECombatShiftStonesCounterStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(26)).gameObject;
							}
						}

						public class PoolFlowStoneRUMBLECombatShiftStonesFlowStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(27)).gameObject;
							}
						}

						public class PoolGuardStoneRUMBLECombatShiftStonesGuardStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(28)).gameObject;
							}
						}

						public class PoolStubbornStoneRUMBLECombatShiftStonesStubbornStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(29)).gameObject;
							}
						}

						public class PoolAdamantStoneRUMBLECombatShiftStonesUnyieldingStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(30)).gameObject;
							}
						}

						public class PoolVigorStoneRUMBLECombatShiftStonesVigorStone
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(31)).gameObject;
							}
						}

						public class PoolSurgestoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(32)).gameObject;
							}
						}

						public class PoolGuardstoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(33)).gameObject;
							}
						}

						public class PoolStubbornstoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(34)).gameObject;
							}
						}

						public class PoolAdamantstoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(35)).gameObject;
							}
						}

						public class PoolVigorstoneVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(36)).gameObject;
							}
						}

						public class PoolSmallRockRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(37)).gameObject;
							}
						}

						public class PoolLargeRockRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(38)).gameObject;
							}
						}

						public class PoolFlickVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(39)).gameObject;
							}
						}

						public class PoolPlayerBoxInteractionVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(40)).gameObject;
							}
						}

						public class PoolExplodeActivationVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(41)).gameObject;
							}
						}

						public class PoolExplodeFinaleVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(42)).gameObject;
							}
						}

						public class PoolExplodeStatusVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(43)).gameObject;
							}
						}

						public class PoolVFXDustModifierDashRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(44)).gameObject;
							}
						}

						public class PoolVFXDustPlayerKnockbackRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(45)).gameObject;
							}
						}

						public class PoolHitmarkerRUMBLEPlayersSubsystemsPlayerHitmarker
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(46)).gameObject;
							}
						}

						public class PoolVFXDustModifierGroundRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(47)).gameObject;
							}
						}

						public class PoolStructureCollisionVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(48)).gameObject;
							}
						}

						public class PoolVFXDustModifierFreeRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(49)).gameObject;
							}
						}

						public class PoolVFXDustModifierJumpRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(50)).gameObject;
							}
						}

						public class PoolPosePerformedVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(51)).gameObject;
							}
						}

						public class PoolMovePerformedVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(52)).gameObject;
							}
						}

						public class PoolRicochetVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(53)).gameObject;
							}
						}

						public class PoolParryVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(54)).gameObject;
							}
						}

						public class PoolHoldVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(55)).gameObject;
							}
						}

						public class PoolUppercutVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(56)).gameObject;
							}
						}

						public class PoolStraightVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(57)).gameObject;
							}
						}

						public class PoolKickVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(58)).gameObject;
							}
						}

						public class PoolStompVFXRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(59)).gameObject;
							}
						}

						public class PoolVFXDustPlayerFootstepRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(60)).gameObject;
							}
						}

						public class PoolPillarRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(61)).gameObject;
							}
						}

						public class PoolDiscRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(62)).gameObject;
							}
						}

						public class PoolVFXDustStructureSpawnRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(63)).gameObject;
							}
						}

						public class PoolVFXDustStructureBreakRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(64)).gameObject;
							}
						}

						public class PoolVFXDustStructureImpactRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(65)).gameObject;
							}
						}

						public class PoolJointControlRUMBLEPhysicsJointControl
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(66)).gameObject;
							}
						}

						public class PoolWallRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(67)).gameObject;
							}
						}

						public class PoolRockCubeRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(68)).gameObject;
							}
						}

						public class PoolBallRUMBLEMoveSystemStructure
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(69)).gameObject;
							}
						}

						public class PoolPooledAudioSourceRUMBLEPoolsPooledAudioSource
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(70)).gameObject;
							}
						}

						public class PoolVFXDustStructureFrictionRUMBLEPoolsPooledVisualEffect
						{
							public static GameObject GetGameObject()
							{
								return ((Component)PoolManager.GetGameObject().transform.GetChild(71)).gameObject;
							}
						}

						public static GameObject GetGameObject()
						{
							return ((Component)PreInitializable.GetGameObject().transform.GetChild(1)).gameObject;
						}
					}

					public class PlayFabHandler
					{
						public static GameObject GetGameObject()
						{
							return ((Component)PreInitializable.GetGameObject().transform.GetChild(2)).gameObject;
						}
					}

					public static GameObject GetGameObject()
					{
						return ((Component)GameInstance.GetGameObject().transform.GetChild(0)).gameObject;
					}
				}

				public class Initializable
				{
					public class NetworkManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(0)).gameObject;
						}
					}

					public class PlayerManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(1)).gameObject;
						}
					}

					public class SceneManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(2)).gameObject;
						}
					}

					public class NotificationManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(3)).gameObject;
						}
					}

					public class StackManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(4)).gameObject;
						}
					}

					public class GraphicsManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(5)).gameObject;
						}
					}

					public class SocialHandler
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(6)).gameObject;
						}
					}

					public class SlabManager
					{
						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(7)).gameObject;
						}
					}

					public class RecordingCamera
					{
						public class FadeScreenRenderer
						{
							public static GameObject GetGameObject()
							{
								return ((Component)RecordingCamera.GetGameObject().transform.GetChild(0)).gameObject;
							}
						}

						public static GameObject GetGameObject()
						{
							return ((Component)Initializable.GetGameObject().transform.GetChild(8)).gameObject;
						}
					}

					public class CatalogHandler
					{
						public static GameObject Ge