using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using DbsContentApi.Patches;
using DefaultNamespace.ContentProviders;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using TMPro;
using UnityEngine;
using UnityEngine.AI;
using UnityEngine.Events;
using UnityEngine.Localization;
using UnityEngine.Localization.Tables;
using UnityEngine.SceneManagement;
using Zorro.Core;
using Zorro.Settings;

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

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

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

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

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace DbsContentApi
{
	[ContentWarningPlugin("db.contentapi", "3.1.1", false)]
	[BepInPlugin("db.contentapi", "DB's Content API", "3.1.1")]
	public class DbsContentApiPlugin : BaseUnityPlugin
	{
		private const string ApiAssetBundleFileName = "dbscontentapi";

		private bool _isPatched;

		private Harmony? _harmony;

		internal static List<GameObject> customMonsters = new List<GameObject>();

		internal static List<CustomMap> customMaps = new List<CustomMap>();

		internal static Dictionary<string, CustomMap> customMapsById = new Dictionary<string, CustomMap>(StringComparer.OrdinalIgnoreCase);

		internal static string? selectedCustomMapId;

		internal static string? forcedNextMapId;

		internal static List<Action> customItemsRegistrationCallbacks = new List<Action>();

		internal static List<Item> customArtifacts = new List<Item>();

		internal static List<ContentEvent> customContentEvents = new List<ContentEvent>();

		internal static bool moddedMobsOnly;

		internal static bool moddedMapsOnly;

		internal static bool allItemsFree;

		internal static List<BaseCWInput> _inputs = new List<BaseCWInput>();

		internal static AssetBundle? ApiAssetBundle { get; private set; }

		public static GameObject? TemporaryContentTriggerPrefab { get; private set; }

		private void Awake()
		{
			LoadApiAssetBundle();
			PatchAll();
			ApiLog.Log("Plugin db.contentapi is loaded!");
		}

		private static void LoadApiAssetBundle()
		{
			string location = Assembly.GetExecutingAssembly().Location;
			ApiAssetBundle = ContentLoader.LoadAssetBundle(location, "dbscontentapi");
			if ((Object)(object)ApiAssetBundle == (Object)null)
			{
				ApiLog.LogError("DbsContentApi: failed to load asset bundle 'dbscontentapi' next to " + location);
				return;
			}
			try
			{
				TemporaryContentTriggerPrefab = ContentLoader.LoadPrefabFromBundle(ApiAssetBundle, "TemporaryContentProviderCube.prefab");
			}
			catch (Exception ex)
			{
				ApiLog.LogError("DbsContentApi: failed to load prefab TemporaryContentProviderCube from bundle: " + ex.Message);
			}
		}

		internal static bool RegisterCustomMap(CustomMap map)
		{
			if (customMapsById.ContainsKey(map.MapId))
			{
				ApiLog.LogError("[Maps] Duplicate map id '" + map.MapId + "'. Registration rejected.");
				return false;
			}
			customMaps.Add(map);
			customMapsById[map.MapId] = map;
			ApiLog.Log($"[Maps] Registered custom map: {map.DisplayName} (Id: {map.MapId}, Index: {customMaps.Count - 1})");
			return true;
		}

		internal static bool TryGetCustomMap(string mapId, out CustomMap? map)
		{
			if (customMapsById.TryGetValue(mapId, out CustomMap value))
			{
				map = value;
				return true;
			}
			map = null;
			return false;
		}

		internal static bool TryGetCustomMapByIndex(int index, out CustomMap? map)
		{
			if (index >= 0 && index < customMaps.Count)
			{
				map = customMaps[index];
				return true;
			}
			map = null;
			return false;
		}

		private void PatchAll()
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			if (_isPatched)
			{
				ApiLog.LogError("Already patched!");
				return;
			}
			ApiLog.Log("Patching...");
			if (_harmony == null)
			{
				_harmony = new Harmony("db.contentapi");
			}
			try
			{
				ApiLog.LogError("Patching...");
				_harmony.PatchAll();
				_isPatched = true;
				ApiLog.Log("Patched!");
			}
			catch (Exception arg)
			{
				ApiLog.LogError($"Failed to patch: {arg}");
			}
		}

		public void UnpatchAll()
		{
			if (!_isPatched)
			{
				ApiLog.LogError("Already unpatched!");
				return;
			}
			ApiLog.Log("Unpatching...");
			try
			{
				Harmony? harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
				_isPatched = false;
				ApiLog.Log("Unpatched!");
			}
			catch (Exception arg)
			{
				ApiLog.LogError($"Failed to unpatch: {arg}");
			}
		}

		public static void SetModdedMobsOnly(bool value)
		{
			moddedMobsOnly = value;
		}

		public static void SetModdedMapsOnly(bool value)
		{
			moddedMapsOnly = value;
		}

		public static void SetAllItemsFree(bool value)
		{
			allItemsFree = value;
		}
	}
	internal static class ApiLog
	{
		internal static void Log(string message)
		{
			Debug.Log((object)("[DbsContentApi] " + message));
		}

		internal static void LogWarning(string message)
		{
			Debug.LogWarning((object)("[DbsContentApi] " + message));
		}

		internal static void LogError(string message)
		{
			Debug.LogError((object)("[DbsContentApi] " + message));
		}
	}
	public abstract class BaseCWInput : KeyCodeSetting
	{
		internal InputKey inputKey;

		protected bool _disabled;

		public void HandleKeys(Player player)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			if (!_disabled)
			{
				KeyCode val = ((KeyCodeSetting)this).Keycode();
				if (Input.GetKeyDown(val))
				{
					OnKeyDown(player);
				}
				else if (Input.GetKeyUp(val))
				{
					OnKeyUp(player);
				}
				else if (Input.GetKey(val))
				{
					OnHeld(player);
				}
			}
		}

		protected abstract override KeyCode GetDefaultKey();

		public override int GetDefaultValue()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected I4, but got Unknown
			return (int)((KeyCodeSetting)this).GetDefaultKey();
		}

		protected abstract void OnKeyDown(Player player);

		protected abstract void OnKeyUp(Player player);

		protected abstract void OnHeld(Player player);

		public void Disable()
		{
			_disabled = true;
		}

		public void Enable()
		{
			_disabled = false;
		}

		public BaseCWInput()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			inputKey = new InputKey();
			DbsContentApiPlugin._inputs.Add(this);
			_disabled = false;
			ApiLog.Log($"[BaseCWInput] Created input: {((object)this).GetType().Name}, default key: {((KeyCodeSetting)this).GetDefaultKey()}");
		}
	}
	public class ContentEvents
	{
		public static void RegisterEvent(ContentEvent contentEvent)
		{
			ApiLog.Log("Registering content event for " + contentEvent.GetName());
			DbsContentApiPlugin.customContentEvents.Add(contentEvent);
		}

		public static ushort GetEventID(string contentEventName)
		{
			List<ContentEvent> customContentEvents = DbsContentApiPlugin.customContentEvents;
			int num = customContentEvents.FindIndex((ContentEvent match) => ((object)match).GetType().Name == contentEventName);
			if (num == -1)
			{
				throw new InvalidOperationException("Content event '" + contentEventName + "' is not registered. Call ContentEvents.RegisterEvent before resolving its ID.");
			}
			return (ushort)(2000 + num);
		}
	}
	[HarmonyPatch(typeof(ContentEventIDMapper))]
	internal class ContentEventIDMapperPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("GetContentEvent")]
		public static bool GetContentEventPrefix(ref ushort id, ref ContentEvent __result)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			List<ContentEvent> customContentEvents = DbsContentApiPlugin.customContentEvents;
			ApiLog.Log($"GetContentEvent was called: {id} Normalized: {id - 2000} EventList count: {customContentEvents.Count}");
			if (id - 2000 < 0)
			{
				return true;
			}
			ContentEvent val = customContentEvents[id - 2000];
			if (val == null)
			{
				return true;
			}
			__result = (ContentEvent)Activator.CreateInstance(((object)val).GetType());
			return false;
		}
	}
	public static class ContentLoader
	{
		public static AssetBundle? LoadAssetBundle(Assembly assembly, string bundleName)
		{
			return LoadAssetBundle(assembly.Location, bundleName);
		}

		public static AssetBundle LoadAssetBundle(string assemblyLocation, string bundleName)
		{
			string directoryName = Path.GetDirectoryName(assemblyLocation);
			string text = Path.Combine(directoryName, bundleName);
			AssetBundle val = AssetBundle.LoadFromFile(text);
			if ((Object)(object)val == (Object)null)
			{
				Debug.LogError((object)("Failed to load AssetBundle: " + bundleName + " at path: " + text));
				return null;
			}
			return val;
		}

		public static GameObject LoadPrefabFromBundle(AssetBundle bundle, string prefabName)
		{
			GameObject val = bundle.LoadAsset<GameObject>(prefabName);
			if ((Object)(object)val == (Object)null)
			{
				throw new Exception("Failed to load Prefab: " + prefabName + " from bundle: " + ((Object)bundle).name);
			}
			return val;
		}

		public static void RegisterPrefabInPhotonPool(GameObject prefab)
		{
			IPunPrefabPool prefabPool = PhotonNetwork.PrefabPool;
			DefaultPool val = (DefaultPool)(object)((prefabPool is DefaultPool) ? prefabPool : null);
			if (val != null && !val.ResourceCache.ContainsKey(((Object)prefab).name))
			{
				val.ResourceCache.Add(((Object)prefab).name, prefab);
			}
		}
	}
	public class CustomComment
	{
		public string Language { get; set; }

		public string Comment { get; set; }

		public CustomComment(string language, string comment)
		{
			Language = language;
			Comment = comment;
		}
	}
	public static class CustomCommentRegistry
	{
		private static Dictionary<string, List<CustomComment>> _registeredComments = new Dictionary<string, List<CustomComment>>();

		public static void Register(string key, params CustomComment[] translations)
		{
			if (!_registeredComments.TryGetValue(key, out List<CustomComment> value))
			{
				value = new List<CustomComment>();
				_registeredComments[key] = value;
			}
			foreach (CustomComment translation in translations)
			{
				CustomComment customComment = value.FirstOrDefault((CustomComment c) => c.Language == translation.Language);
				if (customComment != null)
				{
					customComment.Comment = translation.Comment;
				}
				else
				{
					value.Add(translation);
				}
			}
		}

		internal static void ApplyToStringTables(Dictionary<LocaleIdentifier, StringTable> tables)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (tables == null)
			{
				ApiLog.LogError("[CustomCommentRegistry] tables dictionary is null.");
				return;
			}
			foreach (KeyValuePair<string, List<CustomComment>> registeredComment in _registeredComments)
			{
				string key = registeredComment.Key;
				List<CustomComment> value = registeredComment.Value;
				CustomComment customComment = value.FirstOrDefault((CustomComment t) => t.Language == "en");
				foreach (KeyValuePair<LocaleIdentifier, StringTable> table in tables)
				{
					LocaleIdentifier localeId = table.Key;
					StringTable value2 = table.Value;
					if (((DetailedLocalizationTable<StringTableEntry>)(object)value2).GetEntry(key) != null)
					{
						ApiLog.LogError("[CustomCommentRegistry] Key collision for '" + key + "' in table '" + ((LocaleIdentifier)(ref localeId)).Code + "'. Skipping.");
						continue;
					}
					CustomComment customComment2 = value.FirstOrDefault((CustomComment t) => t.Language == ((LocaleIdentifier)(ref localeId)).Code);
					if (customComment2 != null)
					{
						((DetailedLocalizationTable<StringTableEntry>)(object)value2).AddEntry(key, customComment2.Comment);
						continue;
					}
					if (customComment != null)
					{
						((DetailedLocalizationTable<StringTableEntry>)(object)value2).AddEntry(key, customComment.Comment);
						continue;
					}
					ApiLog.LogError("[CustomCommentRegistry] No translation or English fallback for key '" + key + "' in locale '" + ((LocaleIdentifier)(ref localeId)).Code + "'.");
				}
			}
			ApiLog.Log($"[CustomCommentRegistry] Applied {_registeredComments.Count} custom comment keys to {tables.Count} string tables.");
		}
	}
	public enum GameMaterial
	{
		M_Debug,
		M_Projector_1,
		M_BoomMic_2,
		M_Projector_4,
		M_Projector_3,
		M_GreenScreen_3,
		M_GreenScreen_1,
		M_GreenScreen_2,
		M_Projector_2,
		M_Projector_5,
		M_Container_2,
		M_Player,
		M_Winch_4,
		M_Winch_6,
		M_Winch_2,
		M_Winch_3,
		M_Winch_1,
		M_Winch_5,
		M_Shroom_1,
		M_ReporterMic_1,
		M_ReporterMic_3,
		M_ReporterMic_2,
		M_Monster_BlackLocal,
		M_HatShop_4,
		M_Book_2,
		M_BoomMic_3,
		M_Monster,
		M_World,
		M_Pool_6,
		M_Jester_1,
		M_Flashlight_2_2,
		M_Flashlight_1_1,
		M_Pool_4,
		M_Radio_4,
		M_Metal,
		M_Hotdog_1,
		M_Goo_3,
		M_Flare_1,
		M_Shroom_2,
		M_FredGull_2,
		M_World_AlphaClip,
		M_Hotdog_3,
		M_Rugby_3,
		M_Rug_6,
		M_Hug,
		M_Radio_1,
		M_Borkin_2,
		M_DarkBlack,
		M_Flashlight_Bright,
		M_SoundPlayer_4,
		M_Laser_Weak,
		M_BatteryLight_Off,
		M_BatteryLight_Green,
		M_BatteryLight_Yellow,
		M_BatteryLight_Red,
		M_Flashlight_1_2,
		M_Flashlight_Off,
		M_Player_1,
		M_PlayerVisor,
		M_OxygenDisplay,
		M_FlashBeam,
		M_World_Local,
		M_FlatUI,
		M_Hamburger_3,
		M_Norf_1,
		M_Norf_2,
		M_Jester_3,
		M_Splash,
		M_VideoCamera_Recording,
		M_Cinema_2,
		M_Hand,
		M_Cutbox_1,
		M_LongFlashlight_2_1,
		M_Cutbox_2,
		M_CD_Plastic,
		M_CD,
		M_VFX_ShockStick,
		M_Light_Bright,
		M_ShockStick_1,
		M_ShockStick_2,
		M_Pool_7,
		M_Defib_3,
		M_Flashlight_3_2,
		M_Pool_8,
		M_Chef_1,
		M_Helmet,
		M_Pirate_3,
		M_Pirate_1,
		M_PlayerHatColor,
		M_Pirate_2,
		M_Rug_3,
		M_VideoCamera_3,
		M_World_ShelfGrate_3,
		M_HatShop_6,
		M_Horn,
		M_VideoCamera_5,
		M_VideoCamera_1,
		M_VideoCamera_2,
		M_Eye,
		M_CameraScreen,
		M_Flare_2,
		M_FlareEYe,
		M_FlareBeam,
		M_Ushanka_2,
		M_Ushanka_1,
		M_Container_1,
		M_Container_3,
		M_Cutbox_3,
		M_Halo,
		M_Beanie_1,
		M_Monster_Dark,
		M_News2,
		M_World_BarbedWire,
		M_World_ShelfGrate_1,
		M_World_ShelfGrate_2,
		M_DivingBell_1,
		M_DivingBell_2,
		M_DivingBell_3,
		M_DivingBell_3_Local,
		M_DivingBell_3_Local_Actually,
		M_DivingBell_4,
		M_DivingBell_4_Local,
		M_DivingBell_4_Local_Actually,
		M_DivingBell_Lever_Local,
		M_Popper_2,
		M_Popper_1,
		M_Popper_4,
		M_Popper_3,
		M_BigSlapPainting_1,
		ParticlesUnlit,
		M_RescueHook_1,
		M_FredGull_1,
		M_Walkie_Talkie_2,
		M_Walkie_Talkie_1,
		M_Walkie_Talkie_3,
		M_Explosion,
		M_Milk1,
		M_Floppy_1,
		M_Hamburger_1,
		M_Hamburger_2,
		M_Hamburger_4,
		M_Jester_4,
		M_VideoDisplayScreen,
		M_Hair_1,
		M_Clown_2,
		M_Cowboy,
		M_Portrait_3,
		M_RescueHook_2,
		M_HookLight,
		M_Apple_3,
		M_Child_5,
		M_Ears_1,
		M_Radio_2,
		M_Radio_3,
		M_Book_1,
		M_Crane,
		M_Cinema_1,
		M_Screen,
		M_Cursor,
		M_Defib_4,
		M_Defib_2,
		M_LongFlashlight_2_2,
		M_Laser,
		M_SoundPlayer_3,
		M_Goo_1,
		M_TitleCardRender,
		M_TitleCard_1,
		M_TitleCard,
		M_TitleCard_2,
		M_GooBright,
		M_FredGull_4,
		M_FredGull_3,
		M_Flashlight_3_1,
		M_Crown,
		M_Copyright_1,
		M_Rugby_2,
		M_Interior_7,
		M_Clown_1,
		M_Hotdog_4,
		M_Top,
		M_Rug_5,
		M_Borkin_1,
		M_House_Glas,
		M_Portrait_1,
		M_Copyright,
		M_HatShop_3,
		M_BoomMic_1,
		M_Foodora,
		M_Jester_2,
		M_Child_4,
		M_Balaclava,
		M_Child_2,
		M_ShopGlass,
		M_Podcast_4,
		M_Podcast_2,
		M_Portrait_2,
		M_SoundPlayer_2,
		M_Goop,
		M_SoundPlayer_1,
		M_HatShop_8,
		M_News1,
		M_Defib_1,
		M_Apple_2,
		M_HatShop_5,
		M_Rug_1,
		M_FrontScreen,
		M_SoundPlayer_5,
		M_Portrait_4,
		M_Child_3,
		M_TaserBeam,
		M_VFX_BombFuze,
		M_Rug_4,
		M_Flashlight_2_1,
		M_Apple_1,
		M_DefaultParticle,
		M_Knifo,
		M_Bucket_1,
		M_Bomb,
		M_Ears_2,
		M_Child_1,
		M_Ears_3,
		M_Cap_1,
		M_Goo_2,
		M_Party_2,
		M_Party_1,
		M_Milk2,
		M_HatShop_7,
		M_Brain_1,
		M_HatShop_2,
		M_Rugby_1,
		M_Witch,
		M_Hotdog_2,
		M_HatShop_1,
		M_Bowler,
		M_Brain_2,
		Jello_PostShader,
		M_DivingScreen_Nice,
		M_Light_Warm,
		M_Asphalt,
		M_Barrel_1,
		M_Barrel_2,
		M_Bed_1,
		M_Bed_2,
		M_Bed_3,
		M_Bed_4,
		M_Bed_5,
		M_Bed_6,
		M_Bed_7,
		M_Bed_Default_1,
		M_House_1,
		M_House_10,
		M_House_11,
		M_House_12,
		M_House_2,
		M_House_3,
		M_House_4,
		M_House_5,
		M_House_6,
		M_House_8,
		M_House_9,
		M_Interior_1,
		M_Interior_2,
		M_Interior_3,
		M_Interior_4,
		M_Interior_5,
		M_Interior_6,
		M_Interior_8,
		M_Rock,
		M_Rug_2,
		M_Rug_7,
		M_Rug_8,
		M_Rug_9,
		M_Solar_1,
		M_Solar_2,
		M_Sunflower_1,
		M_Sunflower_2,
		M_Sunflower_3,
		M_ThePlan_1,
		M_ThePlan_2,
		M_Trunk,
		M_Surf_Bush,
		M_Surf_Ground,
		M_Surf_GroundGrass,
		M_DivingBell1Nice,
		M_DivingBell2Nice,
		M_DivingBell3Nice,
		M_DivingBell4Nice,
		M_DivingBell5Nice,
		M_DivingBell6Nice,
		M_CloudSphere_2,
		M_CloudSphere,
		M_CloudSphere_Evening_2,
		M_CloudSphere_Evening,
		M_Sky,
		M_Sky_Evening,
		M_Intro,
		M_House_7,
		M_Scraper,
		M_Invis,
		M_Mirror,
		M_ArrowIcon,
		M_CamConverter_1,
		M_CamConverter_2,
		M_CamConverter_3,
		M_CamConverter_4,
		M_CamConverter_5,
		M_CameraIcon,
		M_Charge_1,
		M_Charge_2,
		M_Charge_3,
		M_Charge_4,
		M_Charge_5,
		M_Drone_1,
		M_Drone_2,
		M_Drone_3,
		M_Drone_4,
		M_Drone_5,
		M_FaceMachine,
		M_House_13,
		M_House_Door,
		M_Landing,
		M_Laptop,
		M_Machine,
		M_NetworkDeal_1,
		M_NetworkDeal_2,
		M_NetworkDeal_3,
		M_NetworkDeal_4,
		M_Podcast_1,
		M_Podcast_10,
		M_Podcast_11,
		M_Podcast_3,
		M_Podcast_5,
		M_Podcast_6,
		M_Podcast_7,
		M_Podcast_8,
		M_Podcast_9,
		M_Pool_1,
		M_Pool_11,
		M_Pool_2,
		M_Pool_3,
		M_Pool_5,
		M_Shop_1,
		M_Shop_2,
		M_Shop_3,
		M_TV_1,
		M_TV_2,
		M_TV,
		M_Teleport_1,
		M_Teleport_2,
		M_Trampoline_1,
		M_Trampoline_2,
		M_Trampoline_3,
		M_Trampoline_4,
		M_UpgradeSign,
		M_Water,
		M_Wood,
		M_Surf_Bush_NoWind,
		M_Surf_Ground_Dirt,
		M_Surf_Ground_Side,
		M_Surf_Ground_Side_Dirt,
		M_Charge,
		M_Dust,
		M_Heal
	}
	public enum DescriptiveMaterial
	{
		TRANSPARENT,
		LIGHT_GREY_1,
		WHITE_1,
		GREY_1,
		MOON,
		GREY_2,
		GREEN_1,
		LIGHT_FLAT_GREY_1,
		GLOWING_WHITE_1,
		DARK_GREY_1,
		DARK_GREY_BLACK,
		DARK_BLUE_CYAN,
		VERY_LIGHT_GREY,
		DARK_GREY_2,
		GREY_WHITE_SPOTS,
		DARKISH_RED_1,
		DARKISH_RED_2,
		WHITE_SPOTS_1,
		DARK_FLAT_GREY_1,
		LIGHT_FLAT_GREY_2,
		DARK_BLUE_GREY,
		FULL_BLACK,
		LIGHT_BROWN,
		WHITE_PAPER,
		GREY_3,
		ORANGE_1,
		YELLOW_1,
		GREY_SPOTS_1,
		BROWN_1,
		BROWN_2,
		ORANGE_2,
		NEUTRAL_GREY,
		VERY_LIGHT_BEIGE,
		DARK_GREY_DARK_SPOTS,
		RED_DARK_SPOTS,
		WHITE_SPOTS_2,
		BLUE_1,
		WEIRD_TRANSPARENT_BLACK_SPOTS,
		RED_1,
		BEIGE_1,
		ORANGE_3,
		YELLOW_2,
		GLOWING_WHITE_2,
		WHITE_DARK_SPOTS,
		TRANSPARENT_SLIGHTLY_RED,
		FLAT_GREY,
		LIME_1,
		GLOWING_YELLOW,
		GLOWING_RED,
		BROWN_DARK_SPOTS,
		BLACK_BLUE,
		GREY_SMALL_DARK_SPOTS,
		ICE_BLUE,
		GREY_DARK_OUTLINES,
		DARK_BLACK_DARK_SPOTS,
		WHITE_2,
		YELLOW_3,
		INTENSE_BLUE_ICE,
		ORANGE_WHITE_SPOTS,
		GREEN_2,
		GLOWING_RED_1,
		WHITE_3,
		DARK_GREY_3,
		WHITE_BEIGE,
		FLAT_DARK_GREY,
		ORANGE_4,
		BLUE_CYAN_1,
		GREY_DARK_SPOTS_1,
		YELLOW_4,
		WHITE_DARKER_SPOTS,
		YELLOW_5,
		BLUE_CYAN_2,
		ORANGE_5,
		RED_BEIGE_1,
		GLOWING_WHITE_3,
		BLACK_GRILLAGE,
		ORANGE_BEIGE_PARALAX,
		GLOWING_WHITE_4,
		GLOWING_RED_2,
		DARK_YELLOW,
		DARK_BROWN,
		GREEN_3,
		DARK_GREY_BROWN,
		RED_BEIGE_LIGHT,
		BROWN_3,
		GLOWING_WHITE_RED,
		GREEN_LEAVES,
		CYAN_BLUE,
		WHITE_4,
		RED_2,
		FLAT_RED,
		VIOLET_1,
		GREEN_4,
		TRANSPARENT_GLASS,
		TRANSPARENT_DARK_WEIRD_LIGHTING,
		BROWN_LARGE_LIGHT_SPOTS,
		GREY_BLUE,
		TRANSPARENT_DARK,
		YELLOW_6,
		RED_MERCURY,
		PINK_1,
		LIME_2,
		DARK_VIOLET,
		RED_3,
		PINK_2,
		ICE_1,
		TURQUOISE,
		RED_4
	}
	public static class GameMaterials
	{
		public static readonly Dictionary<GameMaterial, Material> _materials;

		public static readonly Dictionary<string, GameMaterial> _nameToEnum;

		public static readonly Dictionary<DescriptiveMaterial, GameMaterial> _descriptiveToOriginal;

		public static event Action? OnMaterialsLoaded;

		static GameMaterials()
		{
			_materials = new Dictionary<GameMaterial, Material>();
			_nameToEnum = new Dictionary<string, GameMaterial>();
			_descriptiveToOriginal = new Dictionary<DescriptiveMaterial, GameMaterial>
			{
				{
					DescriptiveMaterial.TRANSPARENT,
					GameMaterial.M_Debug
				},
				{
					DescriptiveMaterial.LIGHT_GREY_1,
					GameMaterial.M_Projector_1
				},
				{
					DescriptiveMaterial.WHITE_1,
					GameMaterial.M_Projector_4
				},
				{
					DescriptiveMaterial.GREY_1,
					GameMaterial.M_Projector_3
				},
				{
					DescriptiveMaterial.MOON,
					GameMaterial.M_GreenScreen_3
				},
				{
					DescriptiveMaterial.GREY_2,
					GameMaterial.M_GreenScreen_1
				},
				{
					DescriptiveMaterial.GREEN_1,
					GameMaterial.M_GreenScreen_2
				},
				{
					DescriptiveMaterial.LIGHT_FLAT_GREY_1,
					GameMaterial.M_Projector_2
				},
				{
					DescriptiveMaterial.GLOWING_WHITE_1,
					GameMaterial.M_Projector_5
				},
				{
					DescriptiveMaterial.DARK_GREY_1,
					GameMaterial.M_Container_2
				},
				{
					DescriptiveMaterial.DARK_GREY_BLACK,
					GameMaterial.M_Player
				},
				{
					DescriptiveMaterial.DARK_BLUE_CYAN,
					GameMaterial.M_Winch_4
				},
				{
					DescriptiveMaterial.VERY_LIGHT_GREY,
					GameMaterial.M_Winch_6
				},
				{
					DescriptiveMaterial.DARK_GREY_2,
					GameMaterial.M_Winch_2
				},
				{
					DescriptiveMaterial.GREY_WHITE_SPOTS,
					GameMaterial.M_Winch_3
				},
				{
					DescriptiveMaterial.DARKISH_RED_1,
					GameMaterial.M_Winch_1
				},
				{
					DescriptiveMaterial.DARKISH_RED_2,
					GameMaterial.M_Winch_5
				},
				{
					DescriptiveMaterial.WHITE_SPOTS_1,
					GameMaterial.M_Shroom_1
				},
				{
					DescriptiveMaterial.DARK_FLAT_GREY_1,
					GameMaterial.M_ReporterMic_1
				},
				{
					DescriptiveMaterial.LIGHT_FLAT_GREY_2,
					GameMaterial.M_ReporterMic_3
				},
				{
					DescriptiveMaterial.DARK_BLUE_GREY,
					GameMaterial.M_ReporterMic_2
				},
				{
					DescriptiveMaterial.FULL_BLACK,
					GameMaterial.M_Monster_BlackLocal
				},
				{
					DescriptiveMaterial.LIGHT_BROWN,
					GameMaterial.M_HatShop_4
				},
				{
					DescriptiveMaterial.WHITE_PAPER,
					GameMaterial.M_Book_2
				},
				{
					DescriptiveMaterial.GREY_3,
					GameMaterial.M_BoomMic_3
				},
				{
					DescriptiveMaterial.ORANGE_1,
					GameMaterial.M_Pool_6
				},
				{
					DescriptiveMaterial.YELLOW_1,
					GameMaterial.M_Jester_1
				},
				{
					DescriptiveMaterial.GREY_SPOTS_1,
					GameMaterial.M_Flashlight_2_2
				},
				{
					DescriptiveMaterial.BROWN_1,
					GameMaterial.M_Flashlight_1_1
				},
				{
					DescriptiveMaterial.BROWN_2,
					GameMaterial.M_Pool_4
				},
				{
					DescriptiveMaterial.ORANGE_2,
					GameMaterial.M_Radio_4
				},
				{
					DescriptiveMaterial.NEUTRAL_GREY,
					GameMaterial.M_Metal
				},
				{
					DescriptiveMaterial.VERY_LIGHT_BEIGE,
					GameMaterial.M_Hotdog_1
				},
				{
					DescriptiveMaterial.DARK_GREY_DARK_SPOTS,
					GameMaterial.M_Goo_3
				},
				{
					DescriptiveMaterial.RED_DARK_SPOTS,
					GameMaterial.M_Flare_1
				},
				{
					DescriptiveMaterial.WHITE_SPOTS_2,
					GameMaterial.M_Shroom_2
				},
				{
					DescriptiveMaterial.BLUE_1,
					GameMaterial.M_FredGull_2
				},
				{
					DescriptiveMaterial.WEIRD_TRANSPARENT_BLACK_SPOTS,
					GameMaterial.M_World_AlphaClip
				},
				{
					DescriptiveMaterial.RED_1,
					GameMaterial.M_Hotdog_3
				},
				{
					DescriptiveMaterial.BEIGE_1,
					GameMaterial.M_Rugby_3
				},
				{
					DescriptiveMaterial.ORANGE_3,
					GameMaterial.M_Rug_6
				},
				{
					DescriptiveMaterial.YELLOW_2,
					GameMaterial.M_Borkin_2
				},
				{
					DescriptiveMaterial.GLOWING_WHITE_2,
					GameMaterial.M_Flashlight_Bright
				},
				{
					DescriptiveMaterial.WHITE_DARK_SPOTS,
					GameMaterial.M_SoundPlayer_4
				},
				{
					DescriptiveMaterial.TRANSPARENT_SLIGHTLY_RED,
					GameMaterial.M_Laser_Weak
				},
				{
					DescriptiveMaterial.FLAT_GREY,
					GameMaterial.M_BatteryLight_Off
				},
				{
					DescriptiveMaterial.LIME_1,
					GameMaterial.M_BatteryLight_Green
				},
				{
					DescriptiveMaterial.GLOWING_YELLOW,
					GameMaterial.M_BatteryLight_Yellow
				},
				{
					DescriptiveMaterial.GLOWING_RED,
					GameMaterial.M_BatteryLight_Red
				},
				{
					DescriptiveMaterial.BROWN_DARK_SPOTS,
					GameMaterial.M_Flashlight_1_2
				},
				{
					DescriptiveMaterial.BLACK_BLUE,
					GameMaterial.M_Flashlight_Off
				},
				{
					DescriptiveMaterial.GREY_SMALL_DARK_SPOTS,
					GameMaterial.M_Player_1
				},
				{
					DescriptiveMaterial.ICE_BLUE,
					GameMaterial.M_PlayerVisor
				},
				{
					DescriptiveMaterial.GREY_DARK_OUTLINES,
					GameMaterial.M_OxygenDisplay
				},
				{
					DescriptiveMaterial.DARK_BLACK_DARK_SPOTS,
					GameMaterial.M_World_Local
				},
				{
					DescriptiveMaterial.WHITE_2,
					GameMaterial.M_FlatUI
				},
				{
					DescriptiveMaterial.YELLOW_3,
					GameMaterial.M_Hamburger_3
				},
				{
					DescriptiveMaterial.INTENSE_BLUE_ICE,
					GameMaterial.M_Norf_1
				},
				{
					DescriptiveMaterial.ORANGE_WHITE_SPOTS,
					GameMaterial.M_Norf_2
				},
				{
					DescriptiveMaterial.GREEN_2,
					GameMaterial.M_Jester_3
				},
				{
					DescriptiveMaterial.GLOWING_RED_1,
					GameMaterial.M_VideoCamera_Recording
				},
				{
					DescriptiveMaterial.WHITE_3,
					GameMaterial.M_Cinema_2
				},
				{
					DescriptiveMaterial.DARK_GREY_3,
					GameMaterial.M_Cutbox_1
				},
				{
					DescriptiveMaterial.WHITE_BEIGE,
					GameMaterial.M_CD_Plastic
				},
				{
					DescriptiveMaterial.FLAT_DARK_GREY,
					GameMaterial.M_ShockStick_1
				},
				{
					DescriptiveMaterial.ORANGE_4,
					GameMaterial.M_ShockStick_2
				},
				{
					DescriptiveMaterial.BLUE_CYAN_1,
					GameMaterial.M_Pool_7
				},
				{
					DescriptiveMaterial.GREY_DARK_SPOTS_1,
					GameMaterial.M_Flashlight_3_2
				},
				{
					DescriptiveMaterial.YELLOW_4,
					GameMaterial.M_Pool_8
				},
				{
					DescriptiveMaterial.WHITE_DARKER_SPOTS,
					GameMaterial.M_Chef_1
				},
				{
					DescriptiveMaterial.YELLOW_5,
					GameMaterial.M_Helmet
				},
				{
					DescriptiveMaterial.BLUE_CYAN_2,
					GameMaterial.M_PlayerHatColor
				},
				{
					DescriptiveMaterial.ORANGE_5,
					GameMaterial.M_Pirate_2
				},
				{
					DescriptiveMaterial.RED_BEIGE_1,
					GameMaterial.M_Rug_3
				},
				{
					DescriptiveMaterial.GLOWING_WHITE_3,
					GameMaterial.M_VideoCamera_3
				},
				{
					DescriptiveMaterial.BLACK_GRILLAGE,
					GameMaterial.M_World_ShelfGrate_3
				},
				{
					DescriptiveMaterial.ORANGE_BEIGE_PARALAX,
					GameMaterial.M_HatShop_6
				},
				{
					DescriptiveMaterial.GLOWING_WHITE_4,
					GameMaterial.M_Eye
				},
				{
					DescriptiveMaterial.GLOWING_RED_2,
					GameMaterial.M_FlareEYe
				},
				{
					DescriptiveMaterial.DARK_YELLOW,
					GameMaterial.M_RescueHook_1
				},
				{
					DescriptiveMaterial.DARK_BROWN,
					GameMaterial.M_Walkie_Talkie_1
				},
				{
					DescriptiveMaterial.GREEN_3,
					GameMaterial.M_Hamburger_4
				},
				{
					DescriptiveMaterial.DARK_GREY_BROWN,
					GameMaterial.M_Hair_1
				},
				{
					DescriptiveMaterial.RED_BEIGE_LIGHT,
					GameMaterial.M_Clown_2
				},
				{
					DescriptiveMaterial.BROWN_3,
					GameMaterial.M_Portrait_3
				},
				{
					DescriptiveMaterial.GLOWING_WHITE_RED,
					GameMaterial.M_HookLight
				},
				{
					DescriptiveMaterial.GREEN_LEAVES,
					GameMaterial.M_Apple_3
				},
				{
					DescriptiveMaterial.CYAN_BLUE,
					GameMaterial.M_Child_1
				},
				{
					DescriptiveMaterial.WHITE_4,
					GameMaterial.M_Cap_1
				},
				{
					DescriptiveMaterial.RED_2,
					GameMaterial.M_Apple_1
				},
				{
					DescriptiveMaterial.FLAT_RED,
					GameMaterial.M_TitleCard_2
				},
				{
					DescriptiveMaterial.VIOLET_1,
					GameMaterial.M_Jester_2
				},
				{
					DescriptiveMaterial.GREEN_4,
					GameMaterial.M_Child_2
				},
				{
					DescriptiveMaterial.TRANSPARENT_GLASS,
					GameMaterial.M_ShopGlass
				},
				{
					DescriptiveMaterial.TRANSPARENT_DARK_WEIRD_LIGHTING,
					GameMaterial.M_Goop
				},
				{
					DescriptiveMaterial.BROWN_LARGE_LIGHT_SPOTS,
					GameMaterial.M_Apple_2
				},
				{
					DescriptiveMaterial.GREY_BLUE,
					GameMaterial.M_Rug_1
				},
				{
					DescriptiveMaterial.TRANSPARENT_DARK,
					GameMaterial.M_FrontScreen
				},
				{
					DescriptiveMaterial.YELLOW_6,
					GameMaterial.M_Child_3
				},
				{
					DescriptiveMaterial.RED_MERCURY,
					GameMaterial.M_Apple_1
				},
				{
					DescriptiveMaterial.PINK_1,
					GameMaterial.M_Ears_2
				},
				{
					DescriptiveMaterial.LIME_2,
					GameMaterial.M_HatShop_2
				},
				{
					DescriptiveMaterial.DARK_VIOLET,
					GameMaterial.M_Bowler
				},
				{
					DescriptiveMaterial.RED_3,
					GameMaterial.M_Bed_2
				},
				{
					DescriptiveMaterial.PINK_2,
					GameMaterial.M_Bed_4
				},
				{
					DescriptiveMaterial.ICE_1,
					GameMaterial.M_Bed_5
				},
				{
					DescriptiveMaterial.TURQUOISE,
					GameMaterial.M_Bed_6
				},
				{
					DescriptiveMaterial.RED_4,
					GameMaterial.M_House_2
				}
			};
			_nameToEnum["M_Debug"] = GameMaterial.M_Debug;
			_nameToEnum["M_Projector 1"] = GameMaterial.M_Projector_1;
			_nameToEnum["M_BoomMic 2"] = GameMaterial.M_BoomMic_2;
			_nameToEnum["M_Projector 4"] = GameMaterial.M_Projector_4;
			_nameToEnum["M_Projector 3"] = GameMaterial.M_Projector_3;
			_nameToEnum["M_GreenScreen 3"] = GameMaterial.M_GreenScreen_3;
			_nameToEnum["M_GreenScreen 1"] = GameMaterial.M_GreenScreen_1;
			_nameToEnum["M_GreenScreen 2"] = GameMaterial.M_GreenScreen_2;
			_nameToEnum["M_Projector 2"] = GameMaterial.M_Projector_2;
			_nameToEnum["M_Projector 5"] = GameMaterial.M_Projector_5;
			_nameToEnum["M_Container 2"] = GameMaterial.M_Container_2;
			_nameToEnum["M_Player"] = GameMaterial.M_Player;
			_nameToEnum["M_Winch 4"] = GameMaterial.M_Winch_4;
			_nameToEnum["M_Winch 6"] = GameMaterial.M_Winch_6;
			_nameToEnum["M_Winch 2"] = GameMaterial.M_Winch_2;
			_nameToEnum["M_Winch 3"] = GameMaterial.M_Winch_3;
			_nameToEnum["M_Winch 1"] = GameMaterial.M_Winch_1;
			_nameToEnum["M_Winch 5"] = GameMaterial.M_Winch_5;
			_nameToEnum["M_Shroom 1"] = GameMaterial.M_Shroom_1;
			_nameToEnum["M_ReporterMic 1"] = GameMaterial.M_ReporterMic_1;
			_nameToEnum["M_ReporterMic 3"] = GameMaterial.M_ReporterMic_3;
			_nameToEnum["M_ReporterMic 2"] = GameMaterial.M_ReporterMic_2;
			_nameToEnum["M_Monster_BlackLocal"] = GameMaterial.M_Monster_BlackLocal;
			_nameToEnum["M_HatShop 4"] = GameMaterial.M_HatShop_4;
			_nameToEnum["M_Book 2"] = GameMaterial.M_Book_2;
			_nameToEnum["M_BoomMic 3"] = GameMaterial.M_BoomMic_3;
			_nameToEnum["M_Monster"] = GameMaterial.M_Monster;
			_nameToEnum["M_World"] = GameMaterial.M_World;
			_nameToEnum["M_Pool 6"] = GameMaterial.M_Pool_6;
			_nameToEnum["M_Jester 1"] = GameMaterial.M_Jester_1;
			_nameToEnum["M_Flashlight 2 2"] = GameMaterial.M_Flashlight_2_2;
			_nameToEnum["M_Flashlight 1 1"] = GameMaterial.M_Flashlight_1_1;
			_nameToEnum["M_Pool 4"] = GameMaterial.M_Pool_4;
			_nameToEnum["M_Radio 4"] = GameMaterial.M_Radio_4;
			_nameToEnum["M_Metal"] = GameMaterial.M_Metal;
			_nameToEnum["M_Hotdog 1"] = GameMaterial.M_Hotdog_1;
			_nameToEnum["M_Goo 3"] = GameMaterial.M_Goo_3;
			_nameToEnum["M_Flare 1"] = GameMaterial.M_Flare_1;
			_nameToEnum["M_Shroom 2"] = GameMaterial.M_Shroom_2;
			_nameToEnum["M_FredGull 2"] = GameMaterial.M_FredGull_2;
			_nameToEnum["M_Hotdog 3"] = GameMaterial.M_Hotdog_3;
			_nameToEnum["M_Rugby 3"] = GameMaterial.M_Rugby_3;
			_nameToEnum["M_Rug 6"] = GameMaterial.M_Rug_6;
			_nameToEnum["M_Hug"] = GameMaterial.M_Hug;
			_nameToEnum["M_Radio 1"] = GameMaterial.M_Radio_1;
			_nameToEnum["M_Borkin 2"] = GameMaterial.M_Borkin_2;
			_nameToEnum["M_World_AlphaClip"] = GameMaterial.M_World_AlphaClip;
			_nameToEnum["M_DarkBlack"] = GameMaterial.M_DarkBlack;
			_nameToEnum["M_Flashlight Bright"] = GameMaterial.M_Flashlight_Bright;
			_nameToEnum["M_SoundPlayer 4"] = GameMaterial.M_SoundPlayer_4;
			_nameToEnum["M_Laser Weak"] = GameMaterial.M_Laser_Weak;
			_nameToEnum["M_BatteryLight_Off"] = GameMaterial.M_BatteryLight_Off;
			_nameToEnum["M_BatteryLight_Green"] = GameMaterial.M_BatteryLight_Green;
			_nameToEnum["M_BatteryLight_Yellow"] = GameMaterial.M_BatteryLight_Yellow;
			_nameToEnum["M_BatteryLight_Red"] = GameMaterial.M_BatteryLight_Red;
			_nameToEnum["M_Flashlight 1 2"] = GameMaterial.M_Flashlight_1_2;
			_nameToEnum["M_Flashlight Off"] = GameMaterial.M_Flashlight_Off;
			_nameToEnum["M_Player 1"] = GameMaterial.M_Player_1;
			_nameToEnum["M_PlayerVisor"] = GameMaterial.M_PlayerVisor;
			_nameToEnum["M_OxygenDisplay"] = GameMaterial.M_OxygenDisplay;
			_nameToEnum["M_FlashBeam"] = GameMaterial.M_FlashBeam;
			_nameToEnum["M_World_Local"] = GameMaterial.M_World_Local;
			_nameToEnum["M_FlatUI"] = GameMaterial.M_FlatUI;
			_nameToEnum["M_Hamburger 3"] = GameMaterial.M_Hamburger_3;
			_nameToEnum["M_Norf 1"] = GameMaterial.M_Norf_1;
			_nameToEnum["M_Norf 2"] = GameMaterial.M_Norf_2;
			_nameToEnum["M_Jester 3"] = GameMaterial.M_Jester_3;
			_nameToEnum["M_Splash"] = GameMaterial.M_Splash;
			_nameToEnum["M_VideoCamera_Recording"] = GameMaterial.M_VideoCamera_Recording;
			_nameToEnum["M_Cinema 2"] = GameMaterial.M_Cinema_2;
			_nameToEnum["M_Hand"] = GameMaterial.M_Hand;
			_nameToEnum["M_Cutbox 1"] = GameMaterial.M_Cutbox_1;
			_nameToEnum["M_LongFlashlight 2 1"] = GameMaterial.M_LongFlashlight_2_1;
			_nameToEnum["M_Cutbox 2"] = GameMaterial.M_Cutbox_2;
			_nameToEnum["M_CD_Plastic"] = GameMaterial.M_CD_Plastic;
			_nameToEnum["M_CD"] = GameMaterial.M_CD;
			_nameToEnum["M_VFX_ShockStick"] = GameMaterial.M_VFX_ShockStick;
			_nameToEnum["M_Light_Bright"] = GameMaterial.M_Light_Bright;
			_nameToEnum["M_ShockStick 1"] = GameMaterial.M_ShockStick_1;
			_nameToEnum["M_ShockStick 2"] = GameMaterial.M_ShockStick_2;
			_nameToEnum["M_Pool 7"] = GameMaterial.M_Pool_7;
			_nameToEnum["M_Defib 3"] = GameMaterial.M_Defib_3;
			_nameToEnum["M_Flashlight 3 2"] = GameMaterial.M_Flashlight_3_2;
			_nameToEnum["M_Pool 8"] = GameMaterial.M_Pool_8;
			_nameToEnum["M_Chef 1"] = GameMaterial.M_Chef_1;
			_nameToEnum["M_Helmet"] = GameMaterial.M_Helmet;
			_nameToEnum["M_Pirate 3"] = GameMaterial.M_Pirate_3;
			_nameToEnum["M_Pirate 1"] = GameMaterial.M_Pirate_1;
			_nameToEnum["M_PlayerHatColor"] = GameMaterial.M_PlayerHatColor;
			_nameToEnum["M_Pirate 2"] = GameMaterial.M_Pirate_2;
			_nameToEnum["M_Rug 3"] = GameMaterial.M_Rug_3;
			_nameToEnum["M_VideoCamera 3"] = GameMaterial.M_VideoCamera_3;
			_nameToEnum["M_World_ShelfGrate 3"] = GameMaterial.M_World_ShelfGrate_3;
			_nameToEnum["M_HatShop 6"] = GameMaterial.M_HatShop_6;
			_nameToEnum["M_Horn"] = GameMaterial.M_Horn;
			_nameToEnum["M_VideoCamera 5"] = GameMaterial.M_VideoCamera_5;
			_nameToEnum["M_VideoCamera 1"] = GameMaterial.M_VideoCamera_1;
			_nameToEnum["M_VideoCamera 2"] = GameMaterial.M_VideoCamera_2;
			_nameToEnum["M_Eye"] = GameMaterial.M_Eye;
			_nameToEnum["M_CameraScreen"] = GameMaterial.M_CameraScreen;
			_nameToEnum["M_Flare 2"] = GameMaterial.M_Flare_2;
			_nameToEnum["M_FlareEYe"] = GameMaterial.M_FlareEYe;
			_nameToEnum["M_FlareBeam"] = GameMaterial.M_FlareBeam;
			_nameToEnum["M_Ushanka 2"] = GameMaterial.M_Ushanka_2;
			_nameToEnum["M_Ushanka 1"] = GameMaterial.M_Ushanka_1;
			_nameToEnum["M_Container 1"] = GameMaterial.M_Container_1;
			_nameToEnum["M_Container 3"] = GameMaterial.M_Container_3;
			_nameToEnum["M_Cutbox 3"] = GameMaterial.M_Cutbox_3;
			_nameToEnum["M_Halo"] = GameMaterial.M_Halo;
			_nameToEnum["M_Beanie 1"] = GameMaterial.M_Beanie_1;
			_nameToEnum["M_Monster_Dark"] = GameMaterial.M_Monster_Dark;
			_nameToEnum["M_News2"] = GameMaterial.M_News2;
			_nameToEnum["M_World_BarbedWire"] = GameMaterial.M_World_BarbedWire;
			_nameToEnum["M_World_ShelfGrate 1"] = GameMaterial.M_World_ShelfGrate_1;
			_nameToEnum["M_World_ShelfGrate 2"] = GameMaterial.M_World_ShelfGrate_2;
			_nameToEnum["M_DivingBell 1"] = GameMaterial.M_DivingBell_1;
			_nameToEnum["M_DivingBell 2"] = GameMaterial.M_DivingBell_2;
			_nameToEnum["M_DivingBell 3"] = GameMaterial.M_DivingBell_3;
			_nameToEnum["M_DivingBell 3_Local"] = GameMaterial.M_DivingBell_3_Local;
			_nameToEnum["M_DivingBell 3_Local Actually"] = GameMaterial.M_DivingBell_3_Local_Actually;
			_nameToEnum["M_DivingBell 4"] = GameMaterial.M_DivingBell_4;
			_nameToEnum["M_DivingBell 4_Local"] = GameMaterial.M_DivingBell_4_Local;
			_nameToEnum["M_DivingBell 4_Local Actually"] = GameMaterial.M_DivingBell_4_Local_Actually;
			_nameToEnum["M_DivingBell Lever_Local"] = GameMaterial.M_DivingBell_Lever_Local;
			_nameToEnum["M_Popper 2"] = GameMaterial.M_Popper_2;
			_nameToEnum["M_Popper 1"] = GameMaterial.M_Popper_1;
			_nameToEnum["M_Popper 4"] = GameMaterial.M_Popper_4;
			_nameToEnum["M_Popper 3"] = GameMaterial.M_Popper_3;
			_nameToEnum["M_BigSlapPainting 1"] = GameMaterial.M_BigSlapPainting_1;
			_nameToEnum["ParticlesUnlit"] = GameMaterial.ParticlesUnlit;
			_nameToEnum["M_RescueHook 1"] = GameMaterial.M_RescueHook_1;
			_nameToEnum["M_FredGull 1"] = GameMaterial.M_FredGull_1;
			_nameToEnum["M_Walkie Talkie 2"] = GameMaterial.M_Walkie_Talkie_2;
			_nameToEnum["M_Walkie Talkie 1"] = GameMaterial.M_Walkie_Talkie_1;
			_nameToEnum["M_Walkie Talkie 3"] = GameMaterial.M_Walkie_Talkie_3;
			_nameToEnum["M_Explosion"] = GameMaterial.M_Explosion;
			_nameToEnum["M_Milk1"] = GameMaterial.M_Milk1;
			_nameToEnum["M_Floppy 1"] = GameMaterial.M_Floppy_1;
			_nameToEnum["M_Hamburger 1"] = GameMaterial.M_Hamburger_1;
			_nameToEnum["M_Hamburger 2"] = GameMaterial.M_Hamburger_2;
			_nameToEnum["M_Hamburger 4"] = GameMaterial.M_Hamburger_4;
			_nameToEnum["M_Jester 4"] = GameMaterial.M_Jester_4;
			_nameToEnum["M_VideoDisplayScreen"] = GameMaterial.M_VideoDisplayScreen;
			_nameToEnum["M_Hair 1"] = GameMaterial.M_Hair_1;
			_nameToEnum["M_Clown 2"] = GameMaterial.M_Clown_2;
			_nameToEnum["M_Cowboy"] = GameMaterial.M_Cowboy;
			_nameToEnum["M_Portrait 3"] = GameMaterial.M_Portrait_3;
			_nameToEnum["M_RescueHook 2"] = GameMaterial.M_RescueHook_2;
			_nameToEnum["M_HookLight"] = GameMaterial.M_HookLight;
			_nameToEnum["M_Apple 3"] = GameMaterial.M_Apple_3;
			_nameToEnum["M_Child 5"] = GameMaterial.M_Child_5;
			_nameToEnum["M_Ears 1"] = GameMaterial.M_Ears_1;
			_nameToEnum["M_Radio 2"] = GameMaterial.M_Radio_2;
			_nameToEnum["M_Radio 3"] = GameMaterial.M_Radio_3;
			_nameToEnum["M_Book 1"] = GameMaterial.M_Book_1;
			_nameToEnum["M_Crane"] = GameMaterial.M_Crane;
			_nameToEnum["M_Cinema 1"] = GameMaterial.M_Cinema_1;
			_nameToEnum["M_Screen"] = GameMaterial.M_Screen;
			_nameToEnum["M_Cursor"] = GameMaterial.M_Cursor;
			_nameToEnum["M_Defib 4"] = GameMaterial.M_Defib_4;
			_nameToEnum["M_Defib 2"] = GameMaterial.M_Defib_2;
			_nameToEnum["M_LongFlashlight 2 2"] = GameMaterial.M_LongFlashlight_2_2;
			_nameToEnum["M_Laser"] = GameMaterial.M_Laser;
			_nameToEnum["M_SoundPlayer 3"] = GameMaterial.M_SoundPlayer_3;
			_nameToEnum["M_Goo 1"] = GameMaterial.M_Goo_1;
			_nameToEnum["M_TitleCardRender"] = GameMaterial.M_TitleCardRender;
			_nameToEnum["M_TitleCard 1"] = GameMaterial.M_TitleCard_1;
			_nameToEnum["M_TitleCard"] = GameMaterial.M_TitleCard;
			_nameToEnum["M_TitleCard 2"] = GameMaterial.M_TitleCard_2;
			_nameToEnum["M_GooBright"] = GameMaterial.M_GooBright;
			_nameToEnum["M_FredGull 4"] = GameMaterial.M_FredGull_4;
			_nameToEnum["M_FredGull 3"] = GameMaterial.M_FredGull_3;
			_nameToEnum["M_Flashlight 3 1"] = GameMaterial.M_Flashlight_3_1;
			_nameToEnum["M_Crown"] = GameMaterial.M_Crown;
			_nameToEnum["M_Copyright 1"] = GameMaterial.M_Copyright_1;
			_nameToEnum["M_Rugby 2"] = GameMaterial.M_Rugby_2;
			_nameToEnum["M_Interior 7"] = GameMaterial.M_Interior_7;
			_nameToEnum["M_Clown 1"] = GameMaterial.M_Clown_1;
			_nameToEnum["M_Hotdog 4"] = GameMaterial.M_Hotdog_4;
			_nameToEnum["M_Top"] = GameMaterial.M_Top;
			_nameToEnum["M_Rug 5"] = GameMaterial.M_Rug_5;
			_nameToEnum["M_Borkin 1"] = GameMaterial.M_Borkin_1;
			_nameToEnum["M_House Glas"] = GameMaterial.M_House_Glas;
			_nameToEnum["M_Portrait 1"] = GameMaterial.M_Portrait_1;
			_nameToEnum["M_Copyright"] = GameMaterial.M_Copyright;
			_nameToEnum["M_HatShop 3"] = GameMaterial.M_HatShop_3;
			_nameToEnum["M_BoomMic 1"] = GameMaterial.M_BoomMic_1;
			_nameToEnum["M_Foodora"] = GameMaterial.M_Foodora;
			_nameToEnum["M_Jester 2"] = GameMaterial.M_Jester_2;
			_nameToEnum["M_Child 4"] = GameMaterial.M_Child_4;
			_nameToEnum["M_Balaclava"] = GameMaterial.M_Balaclava;
			_nameToEnum["M_Child 2"] = GameMaterial.M_Child_2;
			_nameToEnum["M_ShopGlass"] = GameMaterial.M_ShopGlass;
			_nameToEnum["M_Podcast 4"] = GameMaterial.M_Podcast_4;
			_nameToEnum["M_Podcast 2"] = GameMaterial.M_Podcast_2;
			_nameToEnum["M_Portrait 2"] = GameMaterial.M_Portrait_2;
			_nameToEnum["M_SoundPlayer 2"] = GameMaterial.M_SoundPlayer_2;
			_nameToEnum["M_Goop"] = GameMaterial.M_Goop;
			_nameToEnum["M_SoundPlayer 1"] = GameMaterial.M_SoundPlayer_1;
			_nameToEnum["M_HatShop 8"] = GameMaterial.M_HatShop_8;
			_nameToEnum["M_News1"] = GameMaterial.M_News1;
			_nameToEnum["M_Defib 1"] = GameMaterial.M_Defib_1;
			_nameToEnum["M_Apple 2"] = GameMaterial.M_Apple_2;
			_nameToEnum["M_HatShop 5"] = GameMaterial.M_HatShop_5;
			_nameToEnum["M_Rug 1"] = GameMaterial.M_Rug_1;
			_nameToEnum["M_FrontScreen"] = GameMaterial.M_FrontScreen;
			_nameToEnum["M_SoundPlayer 5"] = GameMaterial.M_SoundPlayer_5;
			_nameToEnum["M_Portrait 4"] = GameMaterial.M_Portrait_4;
			_nameToEnum["M_Child 3"] = GameMaterial.M_Child_3;
			_nameToEnum["M_TaserBeam"] = GameMaterial.M_TaserBeam;
			_nameToEnum["M_VFX_BombFuze"] = GameMaterial.M_VFX_BombFuze;
			_nameToEnum["M_Rug 4"] = GameMaterial.M_Rug_4;
			_nameToEnum["M_Flashlight 2 1"] = GameMaterial.M_Flashlight_2_1;
			_nameToEnum["M_Apple 1"] = GameMaterial.M_Apple_1;
			_nameToEnum["M_DefaultParticle"] = GameMaterial.M_DefaultParticle;
			_nameToEnum["M_Knifo"] = GameMaterial.M_Knifo;
			_nameToEnum["M_Bucket 1"] = GameMaterial.M_Bucket_1;
			_nameToEnum["M_Bomb"] = GameMaterial.M_Bomb;
			_nameToEnum["M_Ears 2"] = GameMaterial.M_Ears_2;
			_nameToEnum["M_Child 1"] = GameMaterial.M_Child_1;
			_nameToEnum["M_Ears 3"] = GameMaterial.M_Ears_3;
			_nameToEnum["M_Cap 1"] = GameMaterial.M_Cap_1;
			_nameToEnum["M_Goo 2"] = GameMaterial.M_Goo_2;
			_nameToEnum["M_Party 2"] = GameMaterial.M_Party_2;
			_nameToEnum["M_Party 1"] = GameMaterial.M_Party_1;
			_nameToEnum["M_Milk2"] = GameMaterial.M_Milk2;
			_nameToEnum["M_HatShop 7"] = GameMaterial.M_HatShop_7;
			_nameToEnum["M_Brain 1"] = GameMaterial.M_Brain_1;
			_nameToEnum["M_HatShop 2"] = GameMaterial.M_HatShop_2;
			_nameToEnum["M_Rugby 1"] = GameMaterial.M_Rugby_1;
			_nameToEnum["M_Witch"] = GameMaterial.M_Witch;
			_nameToEnum["M_Hotdog 2"] = GameMaterial.M_Hotdog_2;
			_nameToEnum["M_HatShop 1"] = GameMaterial.M_HatShop_1;
			_nameToEnum["M_Bowler"] = GameMaterial.M_Bowler;
			_nameToEnum["M_Brain 2"] = GameMaterial.M_Brain_2;
			_nameToEnum["Jello_PostShader"] = GameMaterial.Jello_PostShader;
			_nameToEnum["M_DivingScreen_Nice"] = GameMaterial.M_DivingScreen_Nice;
			_nameToEnum["M_Light_Warm"] = GameMaterial.M_Light_Warm;
			_nameToEnum["M_Asphalt"] = GameMaterial.M_Asphalt;
			_nameToEnum["M_Barrel 1"] = GameMaterial.M_Barrel_1;
			_nameToEnum["M_Barrel 2"] = GameMaterial.M_Barrel_2;
			_nameToEnum["M_Bed 1"] = GameMaterial.M_Bed_1;
			_nameToEnum["M_Bed 2"] = GameMaterial.M_Bed_2;
			_nameToEnum["M_Bed 3"] = GameMaterial.M_Bed_3;
			_nameToEnum["M_Bed 4"] = GameMaterial.M_Bed_4;
			_nameToEnum["M_Bed 5"] = GameMaterial.M_Bed_5;
			_nameToEnum["M_Bed 6"] = GameMaterial.M_Bed_6;
			_nameToEnum["M_Bed 7"] = GameMaterial.M_Bed_7;
			_nameToEnum["M_Bed Default 1"] = GameMaterial.M_Bed_Default_1;
			_nameToEnum["M_House 1"] = GameMaterial.M_House_1;
			_nameToEnum["M_House 10"] = GameMaterial.M_House_10;
			_nameToEnum["M_House 11"] = GameMaterial.M_House_11;
			_nameToEnum["M_House 12"] = GameMaterial.M_House_12;
			_nameToEnum["M_House 2"] = GameMaterial.M_House_2;
			_nameToEnum["M_House 3"] = GameMaterial.M_House_3;
			_nameToEnum["M_House 4"] = GameMaterial.M_House_4;
			_nameToEnum["M_House 5"] = GameMaterial.M_House_5;
			_nameToEnum["M_House 6"] = GameMaterial.M_House_6;
			_nameToEnum["M_House 8"] = GameMaterial.M_House_8;
			_nameToEnum["M_House 9"] = GameMaterial.M_House_9;
			_nameToEnum["M_Interior 1"] = GameMaterial.M_Interior_1;
			_nameToEnum["M_Interior 2"] = GameMaterial.M_Interior_2;
			_nameToEnum["M_Interior 3"] = GameMaterial.M_Interior_3;
			_nameToEnum["M_Interior 4"] = GameMaterial.M_Interior_4;
			_nameToEnum["M_Interior 5"] = GameMaterial.M_Interior_5;
			_nameToEnum["M_Interior 6"] = GameMaterial.M_Interior_6;
			_nameToEnum["M_Interior 8"] = GameMaterial.M_Interior_8;
			_nameToEnum["M_Rock"] = GameMaterial.M_Rock;
			_nameToEnum["M_Rug 2"] = GameMaterial.M_Rug_2;
			_nameToEnum["M_Rug 7"] = GameMaterial.M_Rug_7;
			_nameToEnum["M_Rug 8"] = GameMaterial.M_Rug_8;
			_nameToEnum["M_Rug 9"] = GameMaterial.M_Rug_9;
			_nameToEnum["M_Solar 1"] = GameMaterial.M_Solar_1;
			_nameToEnum["M_Solar 2"] = GameMaterial.M_Solar_2;
			_nameToEnum["M_Sunflower 1"] = GameMaterial.M_Sunflower_1;
			_nameToEnum["M_Sunflower 2"] = GameMaterial.M_Sunflower_2;
			_nameToEnum["M_Sunflower 3"] = GameMaterial.M_Sunflower_3;
			_nameToEnum["M_ThePlan 1"] = GameMaterial.M_ThePlan_1;
			_nameToEnum["M_ThePlan 2"] = GameMaterial.M_ThePlan_2;
			_nameToEnum["M_Trunk"] = GameMaterial.M_Trunk;
			_nameToEnum["M_Surf_Bush"] = GameMaterial.M_Surf_Bush;
			_nameToEnum["M_Surf_Ground"] = GameMaterial.M_Surf_Ground;
			_nameToEnum["M_Surf_GroundGrass"] = GameMaterial.M_Surf_GroundGrass;
			_nameToEnum["M_DivingBell1Nice"] = GameMaterial.M_DivingBell1Nice;
			_nameToEnum["M_DivingBell2Nice"] = GameMaterial.M_DivingBell2Nice;
			_nameToEnum["M_DivingBell3Nice"] = GameMaterial.M_DivingBell3Nice;
			_nameToEnum["M_DivingBell4Nice"] = GameMaterial.M_DivingBell4Nice;
			_nameToEnum["M_DivingBell5Nice"] = GameMaterial.M_DivingBell5Nice;
			_nameToEnum["M_DivingBell6Nice"] = GameMaterial.M_DivingBell6Nice;
			_nameToEnum["M_CloudSphere 2"] = GameMaterial.M_CloudSphere_2;
			_nameToEnum["M_CloudSphere"] = GameMaterial.M_CloudSphere;
			_nameToEnum["M_CloudSphere_Evening 2"] = GameMaterial.M_CloudSphere_Evening_2;
			_nameToEnum["M_CloudSphere_Evening"] = GameMaterial.M_CloudSphere_Evening;
			_nameToEnum["M_Sky"] = GameMaterial.M_Sky;
			_nameToEnum["M_Sky_Evening"] = GameMaterial.M_Sky_Evening;
			_nameToEnum["M_Intro"] = GameMaterial.M_Intro;
			_nameToEnum["M_House 7"] = GameMaterial.M_House_7;
			_nameToEnum["M_Scraper"] = GameMaterial.M_Scraper;
			_nameToEnum["M_Invis"] = GameMaterial.M_Invis;
			_nameToEnum["M_Mirror"] = GameMaterial.M_Mirror;
			_nameToEnum["M_ArrowIcon"] = GameMaterial.M_ArrowIcon;
			_nameToEnum["M_CamConverter 1"] = GameMaterial.M_CamConverter_1;
			_nameToEnum["M_CamConverter 2"] = GameMaterial.M_CamConverter_2;
			_nameToEnum["M_CamConverter 3"] = GameMaterial.M_CamConverter_3;
			_nameToEnum["M_CamConverter 4"] = GameMaterial.M_CamConverter_4;
			_nameToEnum["M_CamConverter 5"] = GameMaterial.M_CamConverter_5;
			_nameToEnum["M_CameraIcon"] = GameMaterial.M_CameraIcon;
			_nameToEnum["M_Charge 1"] = GameMaterial.M_Charge_1;
			_nameToEnum["M_Charge 2"] = GameMaterial.M_Charge_2;
			_nameToEnum["M_Charge 3"] = GameMaterial.M_Charge_3;
			_nameToEnum["M_Charge 4"] = GameMaterial.M_Charge_4;
			_nameToEnum["M_Charge 5"] = GameMaterial.M_Charge_5;
			_nameToEnum["M_Drone 1"] = GameMaterial.M_Drone_1;
			_nameToEnum["M_Drone 2"] = GameMaterial.M_Drone_2;
			_nameToEnum["M_Drone 3"] = GameMaterial.M_Drone_3;
			_nameToEnum["M_Drone 4"] = GameMaterial.M_Drone_4;
			_nameToEnum["M_Drone 5"] = GameMaterial.M_Drone_5;
			_nameToEnum["M_FaceMachine"] = GameMaterial.M_FaceMachine;
			_nameToEnum["M_House 13"] = GameMaterial.M_House_13;
			_nameToEnum["M_House Door"] = GameMaterial.M_House_Door;
			_nameToEnum["M_Landing"] = GameMaterial.M_Landing;
			_nameToEnum["M_Laptop"] = GameMaterial.M_Laptop;
			_nameToEnum["M_Machine"] = GameMaterial.M_Machine;
			_nameToEnum["M_NetworkDeal 1"] = GameMaterial.M_NetworkDeal_1;
			_nameToEnum["M_NetworkDeal 2"] = GameMaterial.M_NetworkDeal_2;
			_nameToEnum["M_NetworkDeal 3"] = GameMaterial.M_NetworkDeal_3;
			_nameToEnum["M_NetworkDeal 4"] = GameMaterial.M_NetworkDeal_4;
			_nameToEnum["M_Podcast 1"] = GameMaterial.M_Podcast_1;
			_nameToEnum["M_Podcast 10"] = GameMaterial.M_Podcast_10;
			_nameToEnum["M_Podcast 11"] = GameMaterial.M_Podcast_11;
			_nameToEnum["M_Podcast 3"] = GameMaterial.M_Podcast_3;
			_nameToEnum["M_Podcast 5"] = GameMaterial.M_Podcast_5;
			_nameToEnum["M_Podcast 6"] = GameMaterial.M_Podcast_6;
			_nameToEnum["M_Podcast 7"] = GameMaterial.M_Podcast_7;
			_nameToEnum["M_Podcast 8"] = GameMaterial.M_Podcast_8;
			_nameToEnum["M_Podcast 9"] = GameMaterial.M_Podcast_9;
			_nameToEnum["M_Pool 1"] = GameMaterial.M_Pool_1;
			_nameToEnum["M_Pool 11"] = GameMaterial.M_Pool_11;
			_nameToEnum["M_Pool 2"] = GameMaterial.M_Pool_2;
			_nameToEnum["M_Pool 3"] = GameMaterial.M_Pool_3;
			_nameToEnum["M_Pool 5"] = GameMaterial.M_Pool_5;
			_nameToEnum["M_Shop 1"] = GameMaterial.M_Shop_1;
			_nameToEnum["M_Shop 2"] = GameMaterial.M_Shop_2;
			_nameToEnum["M_Shop 3"] = GameMaterial.M_Shop_3;
			_nameToEnum["M_TV 1"] = GameMaterial.M_TV_1;
			_nameToEnum["M_TV 2"] = GameMaterial.M_TV_2;
			_nameToEnum["M_TV"] = GameMaterial.M_TV;
			_nameToEnum["M_Teleport 1"] = GameMaterial.M_Teleport_1;
			_nameToEnum["M_Teleport 2"] = GameMaterial.M_Teleport_2;
			_nameToEnum["M_Trampoline 1"] = GameMaterial.M_Trampoline_1;
			_nameToEnum["M_Trampoline 2"] = GameMaterial.M_Trampoline_2;
			_nameToEnum["M_Trampoline 3"] = GameMaterial.M_Trampoline_3;
			_nameToEnum["M_Trampoline 4"] = GameMaterial.M_Trampoline_4;
			_nameToEnum["M_UpgradeSign"] = GameMaterial.M_UpgradeSign;
			_nameToEnum["M_Water"] = GameMaterial.M_Water;
			_nameToEnum["M_Wood"] = GameMaterial.M_Wood;
			_nameToEnum["M_Surf_Bush_NoWind"] = GameMaterial.M_Surf_Bush_NoWind;
			_nameToEnum["M_Surf_Ground_Dirt"] = GameMaterial.M_Surf_Ground_Dirt;
			_nameToEnum["M_Surf_Ground_Side"] = GameMaterial.M_Surf_Ground_Side;
			_nameToEnum["M_Surf_Ground_Side_Dirt"] = GameMaterial.M_Surf_Ground_Side_Dirt;
			_nameToEnum["M_Charge"] = GameMaterial.M_Charge;
			_nameToEnum["M_Dust"] = GameMaterial.M_Dust;
			_nameToEnum["M_Heal"] = GameMaterial.M_Heal;
		}

		public static void ApplyOnLoad(GameObject target, GameMaterial material, bool recursive = false)
		{
			OnMaterialsLoaded += delegate
			{
				ApplyMaterial(target, material, recursive);
			};
		}

		public static void InitMaterials()
		{
			Material[] array = Resources.FindObjectsOfTypeAll<Material>();
			HashSet<string> hashSet = new HashSet<string>();
			List<Material> list = new List<Material>();
			Material[] array2 = array;
			foreach (Material val in array2)
			{
				if (hashSet.Add(((Object)val).name))
				{
					list.Add(val);
				}
			}
			ApiLog.Log($"Found {list.Count} unique materials in game resources");
			ApiLog.Log("Unique material names: " + string.Join(", ", hashSet.ToList()));
			foreach (Material item in list)
			{
				if (_nameToEnum.TryGetValue(((Object)item).name, out var value))
				{
					if (!_materials.ContainsKey(value))
					{
						_materials[value] = item;
					}
				}
				else
				{
					ApiLog.LogError("Could not find material: " + ((Object)item).name + " in _nameToEnum, skipping");
				}
			}
			ApiLog.Log($"Loaded {_materials.Count} materials");
			GameMaterials.OnMaterialsLoaded?.Invoke();
		}

		public static Material GetMaterial(GameMaterial type)
		{
			if (!_materials.TryGetValue(type, out Material value))
			{
				return null;
			}
			return value;
		}

		public static Material GetMaterial(DescriptiveMaterial type)
		{
			if (_descriptiveToOriginal.TryGetValue(type, out var value))
			{
				return GetMaterial(value);
			}
			return null;
		}

		public static void ApplyMaterial(GameObject target, GameMaterial type, bool deepApply = true)
		{
			Material material = GetMaterial(type);
			if ((Object)(object)material != (Object)null)
			{
				ApplyToTarget(target, material, deepApply);
			}
		}

		public static void ApplyMaterial(GameObject target, DescriptiveMaterial type, bool deepApply = true)
		{
			Material material = GetMaterial(type);
			if ((Object)(object)material != (Object)null)
			{
				ApplyToTarget(target, material, deepApply);
			}
		}

		public static void ApplyToChild(GameObject root, string childPath, GameMaterial material, bool deep = false)
		{
			Transform val = root.transform.Find(childPath);
			if ((Object)(object)val != (Object)null)
			{
				ApplyMaterial(((Component)val).gameObject, material, deep);
				return;
			}
			ApiLog.Log("Warning: GameMaterials.ApplyToChild: Child path '" + childPath + "' not found on '" + ((Object)root).name + "'");
		}

		public static void ApplyToChild(GameObject root, string childPath, DescriptiveMaterial material, bool deep = false)
		{
			Transform val = root.transform.Find(childPath);
			if ((Object)(object)val != (Object)null)
			{
				ApplyMaterial(((Component)val).gameObject, material, deep);
				return;
			}
			ApiLog.Log("Warning: GameMaterials.ApplyToChild: Child path '" + childPath + "' not found on '" + ((Object)root).name + "'");
		}

		public static void ApplyMaterial(GameObject root, string childPath, GameMaterial material, bool deep = false)
		{
			ApplyToChild(root, childPath, material, deep);
		}

		public static void ApplyMaterial(GameObject root, string childPath, DescriptiveMaterial material, bool deep = false)
		{
			ApplyToChild(root, childPath, material, deep);
		}

		public static void SetMaterials(Renderer renderer, params GameMaterial[] materials)
		{
			if (!((Object)(object)renderer == (Object)null))
			{
				Material[] array = (Material[])(object)new Material[materials.Length];
				for (int i = 0; i < materials.Length; i++)
				{
					array[i] = GetMaterial(materials[i]);
				}
				renderer.materials = array;
			}
		}

		public static void SetMaterials(Renderer renderer, params DescriptiveMaterial[] materials)
		{
			if (!((Object)(object)renderer == (Object)null))
			{
				Material[] array = (Material[])(object)new Material[materials.Length];
				for (int i = 0; i < materials.Length; i++)
				{
					array[i] = GetMaterial(materials[i]);
				}
				renderer.materials = array;
			}
		}

		public static void SetMaterialAt(Renderer renderer, int slot, GameMaterial material)
		{
			if (!((Object)(object)renderer == (Object)null))
			{
				Material[] materials = renderer.materials;
				if (slot >= 0 && slot < materials.Length)
				{
					materials[slot] = GetMaterial(material);
					renderer.materials = materials;
				}
			}
		}

		public static void SetMaterialAt(Renderer renderer, int slot, DescriptiveMaterial material)
		{
			if (!((Object)(object)renderer == (Object)null))
			{
				Material[] materials = renderer.materials;
				if (slot >= 0 && slot < materials.Length)
				{
					materials[slot] = GetMaterial(material);
					renderer.materials = materials;
				}
			}
		}

		public static void SetMaterialAt(GameObject target, int slot, GameMaterial material)
		{
			Renderer component = target.GetComponent<Renderer>();
			if ((Object)(object)component != (Object)null)
			{
				SetMaterialAt(component, slot, material);
			}
		}

		public static void SetMaterialAt(GameObject target, int slot, DescriptiveMaterial material)
		{
			Renderer component = target.GetComponent<Renderer>();
			if ((Object)(object)component != (Object)null)
			{
				SetMaterialAt(component, slot, material);
			}
		}

		public static void ApplyMaterial(ParticleSystem ps, GameMaterial material, bool trailMaterial = false)
		{
			if ((Object)(object)ps == (Object)null)
			{
				return;
			}
			ParticleSystemRenderer component = ((Component)ps).GetComponent<ParticleSystemRenderer>();
			if (!((Object)(object)component == (Object)null))
			{
				Material material2 = GetMaterial(material);
				if (trailMaterial)
				{
					component.trailMaterial = material2;
				}
				else
				{
					((Renderer)component).material = material2;
				}
			}
		}

		public static void ApplyMaterial(ParticleSystem ps, DescriptiveMaterial material, bool trailMaterial = false)
		{
			if ((Object)(object)ps == (Object)null)
			{
				return;
			}
			ParticleSystemRenderer component = ((Component)ps).GetComponent<ParticleSystemRenderer>();
			if (!((Object)(object)component == (Object)null))
			{
				Material material2 = GetMaterial(material);
				if (trailMaterial)
				{
					component.trailMaterial = material2;
				}
				else
				{
					((Renderer)component).material = material2;
				}
			}
		}

		public static Material CloneMaterial(GameMaterial source, string? name = null)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			Material material = GetMaterial(source);
			if ((Object)(object)material == (Object)null)
			{
				ApiLog.Log($"Warning: GameMaterials.CloneMaterial: Base material {source} not found (maybe materials not loaded yet?)");
				return null;
			}
			Material val = new Material(material);
			if (name != null)
			{
				((Object)val).name = name;
			}
			return val;
		}

		public static Material CloneMaterial(GameMaterial source, Texture2D texture, string? name = null)
		{
			Material val = CloneMaterial(source, name);
			if ((Object)(object)val != (Object)null && (Object)(object)texture != (Object)null)
			{
				if (val.HasProperty("_Variation"))
				{
					val.SetTexture("_Variation", (Texture)(object)texture);
				}
				else if (val.HasProperty("_MainTex"))
				{
					val.SetTexture("_MainTex", (Texture)(object)texture);
				}
				else
				{
					val.mainTexture = (Texture)(object)texture;
				}
			}
			return val;
		}

		public static MaterialApplicator Batch(GameObject root)
		{
			return new MaterialApplicator(root);
		}

		private static void ApplyToTarget(GameObject target, Material mat, bool deepApply)
		{
			if (deepApply)
			{
				Renderer[] componentsInChildren = target.GetComponentsInChildren<Renderer>(true);
				foreach (Renderer r in componentsInChildren)
				{
					ApplyToRenderer(r, mat);
				}
			}
			else
			{
				Renderer component = target.GetComponent<Renderer>();
				if ((Object)(object)component != (Object)null)
				{
					ApplyToRenderer(component, mat);
				}
			}
		}

		private static void ApplyToRenderer(Renderer r, Material mat)
		{
			Material[] materials = r.materials;
			for (int i = 0; i < materials.Length; i++)
			{
				materials[i] = mat;
			}
			r.materials = materials;
		}
	}
	public class MaterialApplicator
	{
		private readonly GameObject _root;

		public MaterialApplicator(GameObject root)
		{
			_root = root;
		}

		public MaterialApplicator Root(GameMaterial material, bool deep = true)
		{
			GameMaterials.ApplyMaterial(_root, material, deep);
			return this;
		}

		public MaterialApplicator Root(DescriptiveMaterial material, bool deep = true)
		{
			GameMaterials.ApplyMaterial(_root, material, deep);
			return this;
		}

		public MaterialApplicator At(string childPath, GameMaterial material, bool deep = false)
		{
			GameMaterials.ApplyToChild(_root, childPath, material, deep);
			return this;
		}

		public MaterialApplicator At(string childPath, DescriptiveMaterial material, bool deep = false)
		{
			GameMaterials.ApplyToChild(_root, childPath, material, deep);
			return this;
		}

		public MaterialApplicator Slots(string childPath, params GameMaterial[] materials)
		{
			Transform val = _root.transform.Find(childPath);
			if ((Object)(object)val != (Object)null)
			{
				Renderer component = ((Component)val).GetComponent<Renderer>();
				if ((Object)(object)component != (Object)null)
				{
					GameMaterials.SetMaterials(component, materials);
				}
			}
			return this;
		}

		public MaterialApplicator Slots(string childPath, params DescriptiveMaterial[] materials)
		{
			Transform val = _root.transform.Find(childPath);
			if ((Object)(object)val != (Object)null)
			{
				Renderer component = ((Component)val).GetComponent<Renderer>();
				if ((Object)(object)component != (Object)null)
				{
					GameMaterials.SetMaterials(component, materials);
				}
			}
			return this;
		}

		public MaterialApplicator Slots(Renderer renderer, params GameMaterial[] materials)
		{
			GameMaterials.SetMaterials(renderer, materials);
			return this;
		}

		public MaterialApplicator Slots(Renderer renderer, params DescriptiveMaterial[] materials)
		{
			GameMaterials.SetMaterials(renderer, materials);
			return this;
		}

		public MaterialApplicator AtSlot(string childPath, int slot, GameMaterial material)
		{
			Transform val = _root.transform.Find(childPath);
			if ((Object)(object)val != (Object)null)
			{
				GameMaterials.SetMaterialAt(((Component)val).gameObject, slot, material);
			}
			return this;
		}

		public MaterialApplicator AtSlot(string childPath, int slot, DescriptiveMaterial material)
		{
			Transform val = _root.transform.Find(childPath);
			if ((Object)(object)val != (Object)null)
			{
				GameMaterials.SetMaterialAt(((Component)val).gameObject, slot, material);
			}
			return this;
		}

		public MaterialApplicator AtParticle(ParticleSystem ps, GameMaterial material, bool trailMaterial = false)
		{
			GameMaterials.ApplyMaterial(ps, material, trailMaterial);
			return this;
		}

		public MaterialApplicator AtParticle(ParticleSystem ps, DescriptiveMaterial material, bool trailMaterial = false)
		{
			GameMaterials.ApplyMaterial(ps, material, trailMaterial);
			return this;
		}
	}
	internal static class GuidHelper
	{
		public static Guid ToDeterministicGuid(string input)
		{
			using MD5 mD = MD5.Create();
			byte[] b = mD.ComputeHash(Encoding.Default.GetBytes(input));
			return new Guid(b);
		}
	}
	public enum ImpactSoundType
	{
		None,
		PlasticBounce1,
		PlasticBounce2,
		PlasticBounce3,
		PlasticBounce4,
		PlasticBounce5,
		PlasticBounce6,
		BombBounce1,
		BombBounce2,
		CDBounce1,
		CDBounce2,
		ContainerBounce1,
		ContainerBounce2,
		ShroomBounce1,
		CanBounce,
		CanBounce1,
		Burger1,
		Burger2
	}
	internal static class ImpactSoundScanner
	{
		public static Dictionary<string, SFX_Instance> FoundImpactSounds = new Dictionary<string, SFX_Instance>();

		public static Dictionary<ImpactSoundType, SFX_Instance> ImpactSounds = new Dictionary<ImpactSoundType, SFX_Instance>();

		private static readonly Dictionary<string, Dictionary<string, ImpactSoundType>> ItemExtractionMap = new Dictionary<string, Dictionary<string, ImpactSoundType>>
		{
			{
				"Boom Mic",
				new Dictionary<string, ImpactSoundType>
				{
					{
						"SFX Plastic Bounce 3",
						ImpactSoundType.PlasticBounce3
					},
					{
						"SFX Plastic Bounce 4",
						ImpactSoundType.PlasticBounce4
					}
				}
			},
			{
				"Camera",
				new Dictionary<string, ImpactSoundType> { 
				{
					"SFX Plastic Bounce 5",
					ImpactSoundType.PlasticBounce5
				} }
			},
			{
				"Defibrilator",
				new Dictionary<string, ImpactSoundType>
				{
					{
						"SFX Bomb Bounce 1",
						ImpactSoundType.BombBounce1
					},
					{
						"SFX Bomb Bounce 2",
						ImpactSoundType.BombBounce2
					}
				}
			},
			{
				"Disc",
				new Dictionary<string, ImpactSoundType>
				{
					{
						"SFX CD Bounce 1",
						ImpactSoundType.CDBounce1
					},
					{
						"SFX CD Bounce 2",
						ImpactSoundType.CDBounce2
					}
				}
			},
			{
				"Goo Ball",
				new Dictionary<string, ImpactSoundType> { 
				{
					"SFX Plastic Bounce 6",
					ImpactSoundType.PlasticBounce6
				} }
			},
			{
				"FredGull",
				new Dictionary<string, ImpactSoundType>
				{
					{
						"SFX Can Bounce",
						ImpactSoundType.CanBounce
					},
					{
						"SFX Can Bounce 1",
						ImpactSoundType.CanBounce1
					}
				}
			},
			{
				"SirMonsterBurger",
				new Dictionary<string, ImpactSoundType>
				{
					{
						"SFX Burger 1",
						ImpactSoundType.Burger1
					},
					{
						"SFX Burger 2",
						ImpactSoundType.Burger2
					}
				}
			},
			{
				"",
				new Dictionary<string, ImpactSoundType>
				{
					{
						"SFX Plastic Bounce 1",
						ImpactSoundType.PlasticBounce1
					},
					{
						"SFX Plastic Bounce 2",
						ImpactSoundType.PlasticBounce2
					},
					{
						"SFX Container Bounce 1",
						ImpactSoundType.ContainerBounce1
					},
					{
						"SFX Container Bounce 2",
						ImpactSoundType.ContainerBounce2
					},
					{
						"SFX Shroom Bounce 1",
						ImpactSoundType.ShroomBounce1
					}
				}
			}
		};

		public static void ScanImpactSounds()
		{
			Debug.Log((object)"[ImpactSoundScanner] Starting scan via ItemDatabase...");
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				Debug.LogError((object)"[ImpactSoundScanner] ItemDatabase instance not found!");
				return;
			}
			FieldInfo objectsField = Items.GetObjectsField(instance);
			List<Item> itemsFromField = Items.GetItemsFromField(objectsField, instance);
			if (itemsFromField == null || itemsFromField.Count == 0)
			{
				Debug.LogError((object)"[ImpactSoundScanner] No items found in ItemDatabase.");
				return;
			}
			foreach (Item item in itemsFromField)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				string text = item.displayName ?? ((Object)item).name ?? "Unknown Item";
				if ((Object)(object)item.itemObject == (Object)null)
				{
					Debug.Log((object)("[ImpactSoundScanner] Skipping item '" + text + "': No itemObject (prefab) assigned."));
					continue;
				}
				PhysicsSound[] componentsInChildren = item.itemObject.GetComponentsInChildren<PhysicsSound>(true);
				if (componentsInChildren.Length == 0)
				{
					continue;
				}
				Debug.Log((object)$"[ImpactSoundScanner] Checking item '{text}' ({componentsInChildren.Length} PhysicsSound components)...");
				PhysicsSound[] array = componentsInChildren;
				foreach (PhysicsSound val in array)
				{
					if (val.impactSounds == null)
					{
						continue;
					}
					SFX_Instance[] impactSounds = val.impactSounds;
					foreach (SFX_Instance val2 in impactSounds)
					{
						if (!((Object)(object)val2 == (Object)null))
						{
							string name = ((Object)val2).name;
							if (!FoundImpactSounds.ContainsKey(name))
							{
								FoundImpactSounds.Add(name, val2);
								Debug.Log((object)("[ImpactSoundScanner] >>> NEW SOUND FOUND: '" + name + "' (Source: " + text + ")"));
							}
						}
					}
				}
			}
			Debug.Log((object)$"[ImpactSoundScanner] Scan complete: {FoundImpactSounds.Count} unique impact sounds cached.");
		}

		public static void InitImpactSounds()
		{
			Debug.Log((object)"[ImpactSoundScanner] Initializing Impact Sounds association...");
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				Debug.LogError((object)"[ImpactSoundScanner] Failed to initialize: ItemDatabase is null!");
				return;
			}
			FieldInfo objectsField = Items.GetObjectsField(instance);
			List<Item> itemsFromField = Items.GetItemsFromField(objectsField, instance);
			int num = 0;
			int num2 = 0;
			foreach (Item item in itemsFromField)
			{
				if ((Object)(object)item == (Object)null || (Object)(object)item.itemObject == (Object)null)
				{
					continue;
				}
				string text = item.displayName ?? "";
				if (!ItemExtractionMap.TryGetValue(text, out Dictionary<string, ImpactSoundType> value))
				{
					continue;
				}
				num++;
				PhysicsSound[] componentsInChildren = item.itemObject.GetComponentsInChildren<PhysicsSound>(true);
				PhysicsSound[] array = componentsInChildren;
				foreach (PhysicsSound val in array)
				{
					if (val.impactSounds == null)
					{
						continue;
					}
					SFX_Instance[] impactSounds = val.impactSounds;
					foreach (SFX_Instance val2 in impactSounds)
					{
						if (!((Object)(object)val2 == (Object)null) && value.TryGetValue(((Object)val2).name, out var value2) && !ImpactSounds.ContainsKey(value2))
						{
							ImpactSounds.Add(value2, val2);
							num2++;
							Debug.Log((object)$"[ImpactSoundScanner] Associated '{((Object)val2).name}' with ImpactSoundType.{value2} (from item '{text}')");
						}
					}
				}
			}
			Debug.Log((object)$"[ImpactSoundScanner] Association phase complete. Processed {num} mapped items, associated {num2} unique sounds.");
			ValidateExtraction();
		}

		private static void ValidateExtraction()
		{
			Debug.Log((object)"[ImpactSoundScanner] Starting extraction validation...");
			int num = 0;
			int num2 = 0;
			foreach (ImpactSoundType value in Enum.GetValues(typeof(ImpactSoundType)))
			{
				if (value != ImpactSoundType.None)
				{
					num2++;
					if (!ImpactSounds.ContainsKey(value))
					{
						Debug.LogError((object)$"[ImpactSoundScanner] VALIDATION FAILURE: Missing sound for type '{value}'");
						num++;
					}
				}
			}
			if (num == 0)
			{
				Debug.Log((object)$"[ImpactSoundScanner] VALIDATION SUCCESS: All {num2} impact sound types are correctly associated.");
			}
			else
			{
				Debug.LogError((object)$"[ImpactSoundScanner] VALIDATION FAILED: {num} / {num2} sounds were not found. Check ItemExtractionMap and logs above.");
			}
		}

		public static SFX_Instance GetImpactSound(ImpactSoundType type)
		{
			if (!ImpactSounds.TryGetValue(type, out SFX_Instance value) || (Object)(object)value == (Object)null)
			{
				return null;
			}
			return Object.Instantiate<SFX_Instance>(value);
		}

		public static SFX_Instance[] GetImpactSounds(params ImpactSoundType[] types)
		{
			List<SFX_Instance> list = new List<SFX_Instance>();
			foreach (ImpactSoundType type in types)
			{
				SFX_Instance impactSound = GetImpactSound(type);
				if ((Object)(object)impactSound != (Object)null)
				{
					list.Add(impactSound);
				}
			}
			return list.ToArray();
		}
	}
	public static class ItemPersistence
	{
		private static readonly List<Func<IEnumerable<Item?>>> InventoryItemProviders = new List<Func<IEnumerable<Item>>>();

		public static void RegisterInventoryItemProvider(Func<IEnumerable<Item?>> provider)
		{
			if (provider == null)
			{
				throw new ArgumentNullException("provider");
			}
			InventoryItemProviders.Add(provider);
		}

		internal static SavedInventoryItem[] AppendProviderItems(SavedInventoryItem[] vanillaResult)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			if (InventoryItemProviders.Count == 0)
			{
				return vanillaResult;
			}
			List<SavedInventoryItem> list = vanillaResult?.ToList() ?? new List<SavedInventoryItem>();
			int num = 0;
			foreach (Func<IEnumerable<Item>> inventoryItemProvider in InventoryItemProviders)
			{
				try
				{
					foreach (Item item in inventoryItemProvider())
					{
						if (!((Object)(object)item == (Object)null))
						{
							list.Add(new SavedInventoryItem(item));
							num++;
						}
					}
				}
				catch (Exception arg)
				{
					ApiLog.LogError($"[ItemPersistence] Provider failed: {arg}");
				}
			}
			if (num > 0)
			{
				ApiLog.Log($"[ItemPersistence] Added {num} extra inventory item(s) to save.");
			}
			return list.ToArray();
		}
	}
	public class CustomShopItemCategory
	{
		public byte index;

		public string name = "Category Name";
	}
	public class ItemConfig
	{
		public string displayName = "";

		public string? persistentId;

		public int price = 100;

		public ShopItemCategory category = (ShopItemCategory)3;

		public bool purchasable = true;

		public int quantity = 1;

		public ItemType itemType = (ItemType)1;

		public float mass = 3f;

		public float groundSizeMultiplier = 1f;

		public float groundMassMultiplier = 1f;

		public bool spawnable = true;

		public RARITY toolSpawnRarity = (RARITY)100;

		public int toolBudgetCost = 1;

		public int budgetCost;

		public float rarity = 1f;

		public Vector3 holdPos = new Vector3(0.3f, -0.3f, 0.7f);

		public Vector3 holdRot = Vector3.zero;

		public bool useAlternativeHoldPos;

		public bool useAlternativeHoldRot;

		public Vector3 alternativeHoldPos = new Vector3(0.3f, -0.3f, 0.7f);

		public Vector3 alternativeHoldRot = Vector3.zero;

		public Sprite? icon;

		[Obsolete("Assign config.icon yourself after loading from a bundle or other source. RegisterItem no longer loads icons from AssetBundles.")]
		public string? iconName;

		public SFX_Instance[]? impactSounds;

		public ImpactSoundType[]? impactSoundTypes;

		public List<ItemKeyTooltip> tooltips = new List<ItemKeyTooltip>();
	}
	public class ArtifactConfig : ItemConfig
	{
		public float contentValue = 50f;

		public string? commentKeyPrefix;

		public string[] comments = Array.Empty<string>();

		public string[] commentKeys = Array.Empty<string>();

		public ushort? contentId;

		public bool registerInRoundSpawns = true;

		public ArtifactConfig()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			itemType = (ItemType)2;
			purchasable = false;
			price = 0;
			category = (ShopItemCategory)1;
			spawnable = true;
			budgetCost = 3;
			rarity = 1f;
		}
	}
	public static class Items
	{
		public static List<CustomShopItemCategory> customCategories = new List<CustomShopItemCategory>();

		public static ShopItemCategory RegisterCustomCategory(string categoryName)
		{
			byte b = (byte)(customCategories.Count + 20);
			customCategories.Add(new CustomShopItemCategory
			{
				index = b,
				name = categoryName
			});
			return (ShopItemCategory)b;
		}

		public static void DeferRegistration(Action callback)
		{
			DbsContentApiPlugin.customItemsRegistrationCallbacks.Add(callback);
		}

		public static void SetupPrefab(GameObject prefab)
		{
			EnsureComponents(prefab);
		}

		private static void EnsureComponents(GameObject prefab)
		{
			if ((Object)(object)prefab.GetComponent<ItemInstance>() == (Object)null)
			{
				prefab.AddComponent<ItemInstance>();
				ApiLog.Log("Added ItemInstance component");
			}
			EnsureHandGizmo(prefab);
		}

		public static void EnsureHandGizmo(GameObject prefab)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)prefab.GetComponentInChildren<HandGizmo>(true) != (Object)null))
			{
				GameObject val = new GameObject("HandGizmo");
				val.transform.SetParent(prefab.transform);
				val.AddComponent<HandGizmo>();
				GameObject val2 = new GameObject("GizmoVisual");
				val2.transform.SetParent(val.transform);
				val2.transform.localPosition = Vector3.zero;
				val2.transform.localRotation = Quaternion.identity;
				ApiLog.Log("Added HandGizmo with dummy child");
			}
		}

		public static Item RegisterItem(GameObject prefab, ItemConfig config)
		{
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)prefab == (Object)null)
			{
				throw new ArgumentNullException("prefab");
			}
			ApiLog.Log("Registering item: " + config.displayName + " (Prefab: " + ((Object)prefab).name + ")");
			SetupPrefab(prefab);
			ContentLoader.RegisterPrefabInPhotonPool(prefab);
			Item val = ScriptableObject.CreateInstance<Item>();
			SFX_Instance[] impactSounds = config.impactSounds;
			if (impactSounds == null && config.impactSoundTypes != null)
			{
				impactSounds = ImpactSoundScanner.GetImpactSounds(config.impactSoundTypes);
			}
			if (impactSounds != null && impactSounds.Length != 0)
			{
				SetupPhysicsSound(prefab, impactSounds);
			}
			if ((Object)(object)config.icon != (Object)null)
			{
				val.icon = config.icon;
			}
			else if (!string.IsNullOrEmpty(config.iconName))
			{
				ApiLog.LogWarning("Item '" + config.displayName + "': config.iconName is obsolete. Load a Sprite and set config.icon before calling RegisterItem.");
			}
			val.displayName = config.displayName;
			val.itemObject = prefab;
			string text = (val.persistentID = config.persistentId ?? ("unknown_mod." + val.displayName.ToLower().Replace(" ", "")));
			val.PersistentID = GuidHelper.ToDeterministicGuid(text);
			((Object)val).name = text;
			val.itemType = config.itemType;
			val.Category = config.category;
			val.mass = config.mass;
			val.holdPos = config.holdPos;
			val.holdRotation = config.holdRot;
			val.useAlternativeHoldingPos = config.useAlternativeHoldPos;
			val.useAlternativeHoldingRot = config.useAlternativeHoldRot;
			val.alternativeHoldPos = config.alternativeHoldPos;
			val.alternativeHoldRot = config.alternativeHoldRot;
			val.groundSizeMultiplier = config.groundSizeMultiplier;
			val.groundMassMultiplier = config.groundMassMultiplier;
			val.purchasable = config.purchasable;
			val.price = config.price;
			val.quantity = config.quantity;
			val.spawnable = config.spawnable;
			val.toolSpawnRarity = config.toolSpawnRarity;
			val.toolBudgetCost = config.toolBudgetCost;
			val.budgetCost = config.budgetCost;
			val.rarity = config.rarity;
			val.content = null;
			val.Tooltips = config.tooltips ?? new List<ItemKeyTooltip>();
			if (!CheckDuplicateItem(val))
			{
				AddItemToDatabase(val);
			}
			return val;
		}

		public static Item RegisterArtifact(GameObject prefab, ArtifactConfig config)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)prefab == (Object)null)
			{
				throw new ArgumentNullException("prefab");
			}
			if (config == null)
			{
				throw new ArgumentNullException("config");
			}
			config.itemType = (ItemType)2;
			config.purchasable = false;
			config.price = 0;
			config.spawnable = true;
			EnsureArtifactContentProvider(prefab);
			Item val = RegisterItem(prefab, config);
			val.content = CreateArtifactContent(val, config);
			if (config.registerInRoundSpawns)
			{
				RegisterArtifactSpawn(val);
			}
			ApiLog.Log($"Artifact '{val.displayName}' registered with content ID: {val.content.id}");
			return val;
		}

		public static void SetupIcon(AssetBundle bundle, Item item, string iconName)
		{
			Sprite val = bundle.LoadAsset<Sprite>(iconName);
			if ((Object)(object)val != (Object)null)
			{
				item.icon = val;
			}
		}

		public static void SetupPhysicsSound(GameObject prefab, SFX_Instance[] impactSounds)
		{
			PhysicsSound val = prefab.GetComponent<PhysicsSound>();
			if ((Object)(object)val == (Object)null)
			{
				val = prefab.AddComponent<PhysicsSound>();
			}
			val.impactSounds = impactSounds;
		}

		private static void EnsureArtifactContentProvider(GameObject prefab)
		{
			if (!((Object)(object)prefab.GetComponent<ArtifactContentProvider>() != (Object)null))
			{
				prefab.AddComponent<ArtifactContentProvider>();
				ApiLog.Log("Added ArtifactContentProvider to " + ((Object)prefab).name);
			}
		}

		private static PropContent CreateArtifactContent(Item item, ArtifactConfig config)
		{
			string[] array = RegisterArtifactComments(item, config);
			if (array.Length == 0)
			{
				ApiLog.LogWarning("Artifact '" + item.displayName + "' has no comments configured.");
			}
			PropContent val = ScriptableObject.CreateInstance<PropContent>();
			((Object)val).name = ((Object)item).name + ".content";
			val.isArtifact = true;
			val.contentValue = config.contentValue;
			val.id = config.contentId ?? GetNextContentId();
			val.comments = array;
			return val;
		}

		private static string[] RegisterArtifactComments(Item item, ArtifactConfig config)
		{
			List<string> list = new List<string>();
			if (config.commentKeys != null)
			{
				list.AddRange(config.commentKeys.Where((string key) => !string.IsNullOrWhiteSpace(key)));
			}
			if (config.comments == null || config.comments.Length == 0)
			{
				return list.Distinct().ToArray();
			}
			string arg = (string.IsNullOrWhiteSpace(config.commentKeyPrefix) ? ("Content_" + SanitizeCommentKey(((Object)item).name) + "_Artifact") : config.commentKeyPrefix);
			for (int num = 0; num < config.comments.Length; num++)
			{
				string text = config.comments[num];
				if (!string.IsNullOrWhiteSpace(text))
				{
					string text2 = $"{arg}_{num}";
					CustomCommentRegistry.Register(text2, new CustomComment("en", text));
					list.Add(text2);
				}
			}
			return list.Distinct().ToArray();
		}

		private static string SanitizeCommentKey(string value)
		{
			char[] array = value.Where((char c) => char.IsLetterOrDigit(c) || c == '_').ToArray();
			if (array.Length != 0)
			{
				return new string(array);
			}
			return "Custom";
		}

		private static ushort GetNextContentId()
		{
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			FieldInfo objectsField = GetObjectsField(instance);
			List<Item> itemsFromField = GetItemsFromField(objectsField, instance);
			ushort num = 0;
			foreach (Item item in itemsFromField)
			{
				if (!((Object)(object)item?.content == (Object)null))
				{
					num = Math.Max(num, item.content.id);
				}
			}
			return (ushort)(num + 1);
		}

		private static void RegisterArtifactSpawn(Item item)
		{
			if (!DbsContentApiPlugin.customArtifacts.Any((Item artifact) => (Object)(object)artifact != (Object)null && artifact.persistentID == item.persistentID))
			{
				DbsContentApiPlugin.customArtifacts.Add(item);
				ApiLog.Log("Artifact '" + item.displayName + "' added to round artifact spawns.");
			}
		}

		public static SFX_Instance[] GetFallbackPhysicsSound(ItemDatabase db)
		{
			FieldInfo objectsField = GetObjectsField(db);
			List<Item> itemsFromField = GetItemsFromField(objectsField, db);
			return itemsFromField[0].itemObject.GetComponent<PhysicsSound>().impactSounds;
		}

		public static SFX_Instance[] CreateSFXInstanceFromClip(AudioClip customSound)
		{
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			FieldInfo objectsField = GetObjectsField(instance);
			List<Item> itemsFromField = GetItemsFromField(objectsField, instance);
			PhysicsSound component = itemsFromField[0].itemObject.GetComponent<PhysicsSound>();
			object obj;
			if (component == null)
			{
				obj = null;
			}
			else
			{
				SFX_Instance[] impactSounds = component.impactSounds;
				obj = ((impactSounds != null) ? impactSounds[0] : null);
			}
			SFX_Instance val = (SFX_Instance)obj;
			if ((Object)(object)val == (Object)null)
			{
				ApiLog.LogError("Could not find template SFX_Instance");
				return GetFallbackPhysicsSound(instance);
			}
			SFX_Instance val2 = Object.Instantiate<SFX_Instance>(val);
			val2.clips = (AudioClip[])(object)new AudioClip[1] { customSound };
			val2.settings.pitch = 1f;
			val2.settings.volume = 1f;
			return (SFX_Instance[])(object)new SFX_Instance[1] { val2 };
		}

		public static SFX_Instance[] CreateImpactSoundFromClips(params AudioClip[] customSounds)
		{
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			FieldInfo objectsField = GetObjectsField(instance);
			List<Item> itemsFromField = GetItemsFromField(objectsField, instance);
			PhysicsSound component = itemsFromField[0].itemObject.GetComponent<PhysicsSound>();
			object obj;
			if (component == null)
			{
				obj = null;
			}
			else
			{
				SFX_Instance[] impactSounds = component.impactSounds;
				obj = ((impactSounds != null) ? impactSounds[0] : null);
			}
			SFX_Instance val = (SFX_Instance)obj;
			if ((Object)(object)val == (Object)null)
			{
				ApiLog.LogError("Could not find template SFX_Instance");
				return GetFallbackPhysicsSound(instance);
			}
			SFX_Instance val2 = Object.Instantiate<SFX_Instance>(val);
			val2.clips = customSounds;
			val2.settings.pitch = 1f;
			val2.settings.volume = 1f;
			return (SFX_Instance[])(object)new SFX_Instance[1] { val2 };
		}

		public static FieldInfo GetObjectsField(ItemDatabase db)
		{
			FieldInfo field = ((object)db).GetType().GetField("Objects", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field == null)
			{
				field = ((object)db).GetType().GetField("objects", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			}
			if (field == null)
			{
				throw new Exception("Could not find Objects field in ItemDatabase");
			}
			return field;
		}

		public static List<Item> GetItemsFromField(FieldInfo objectsField, ItemDatabase db)
		{
			object value = objectsField.GetValue(db);
			if (value is List<Item> result)
			{
				return result;
			}
			if (value is Item[] collection)
			{
				return new List<Item>(collection);
			}
			throw new Exception("Objects field is type " + (value?.GetType()?.Name ?? "null") + ", expected List<Item> or Item[]");
		}

		public static Item? GetItemByPrefabComponent<T>() where T : Component
		{
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			FieldInfo objectsField = GetObjectsField(instance);
			List<Item> itemsFromField = GetItemsFromField(objectsField, instance);
			foreach (Item item in itemsFromField)
			{
				if ((Object)(object)item?.itemObject != (Object)null && (Object)(object)item.itemObject.GetComponent<T>() != (Object)null)
				{
					return item;
				}
			}
			return null;
		}

		public static void AddItemToDatabase(Item item)
		{
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			FieldInfo objectsField = GetObjectsField(instance);
			List<Item> itemsFromField = GetItemsFromField(objectsField, instance);
			item.id = (byte)((itemsFromField.Count > 0) ? ((byte)(itemsFromField.Max((Item i) => i.id) + 1)) : 0);
			itemsFromField.Add(item);
			objectsField.SetValue(instance, itemsFromField);
			ApiLog.Log($"Item '{item.displayName}' registered with ID: {item.id}");
		}

		public static void SetAllItemsFree()
		{
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			FieldInfo objectsField = GetObjectsField(instance);
			List<Item> itemsFromField = GetItemsFromField(objectsField, instance);
			foreach (Item item in itemsFromField)
			{
				if ((Object)(object)item != (Object)null)
				{
					item.price = 0;
				}
			}
			objectsField.SetValue(instance, itemsFromField);
		}

		public static bool CheckDuplicateItem(Item item)
		{
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			FieldInfo objectsField = GetObjectsField(instance);
			List<Item> itemsFromField = GetItemsFromField(objectsField, instance);
			if (itemsFromField.Count == 0)
			{
				return false;
			}
			for (int i = 0; i < itemsFromField.Count; i++)
			{
				if (itemsFromField[i].displayName == item.displayName)
				{
					return true;
				}
			}
			return false;
		}

		public static Item? GetItemByID(byte id)
		{
			ItemDatabase instance = SingletonAsset<ItemDatabase>.Instance;
			FieldInfo objectsField = GetObjectsField(instance);
			List<Item> itemsFromField = GetItemsFromField(objectsField, instance);
			return ((IEnumerable<Item>)itemsFromField).FirstOrDefault((Func<Item, bool>)((Item i) => (Object)(object)i != (Object)null && i.id == id));
		}
	}
	public class MapPipelineFlags
	{
		public bool skipVanillaCleanup;

		public bool skipRetexture;

		public bool skipPatrolSetup;

		public bool skipMonsterRemoval;

		public bool skipMultipliers;

		public bool skipAmbience;

		public bool skipDiveBellTeleport;

		public bool skipFinalize;
	}
	public class MapConfig
	{
		public MapPipelineFlags pipeline = new MapPipelineFlags();

		public float patrolConnectionRadius = 64f;

		public int patrolConnectionLayerMask = 1024;

		public bool retextureScene = true;

		public Color retextureColor = Color.gray;

		public bool setupAmbience = true;

		public float ambienceVolumeMultiplier = 6f;

		public bool setupPatrolPoints = true;

		public bool patrolGroupFromName = true;

		public string patrolNameSeparator = "_";

		public PatrolGroup? defaultPatrolGroup = (PatrolGroup)4;

		public bool assignUnspecifiedToAllGroups;

		public bool respectScenePatrolPoints = true;

		public float defaultPatrolSpawnWeight = 1f;

		public bool patrolGroupScopedConnections = true;

		public bool applyMonsterRemoval = true;

		public bool setupMultipliers = true;

		public string diveBellSpawnMarker = "DiveBellSpawn";

		public string patrolPointMarker = "PatrolPoint";

		public string roundRemoveHandlerName = "RoundRemoveHandler";

		public string roundMultiplierHandlerName = "RoundMultiplierHandler";

		public string ambienceHolderName = "AmbienceHolder";

		public List<string> extraKeepObjects = new List<string>();
	}
	public class MapLifecycleHooks
	{
		public Action<MapLoadContext>? onBeforeCleanup;

		public Action<MapLoadContext>? onAfterSceneLoaded;

		public Action<MapLoadContext>? onAfterSetup;
	}
	public class MapLoadContext
	{
		public CustomMap Map { get; }

		public MapConfig Config => Map.Config;

		public CustomMapLoader Loader { get; }

		public Scene ActiveScene { get; internal set; }

		public Scene? LoadedScene { get; internal set; }

		public List<GameObject> DiveBellSpawns { get; } = new List<GameObject>();

		public List<PatrolPoint> PatrolPoints { get; } = new List<PatrolPoint>();

		internal MapLoadContext(CustomMap map, CustomMapLoader loader)
		{
			Map = map;
			Loader = loader;
		}
	}
	public class CustomMap
	{
		public AssetBundle Bundle { get; }

		public string SceneName { get; }

		public string DisplayName { get; }

		public string MapId { get; }

		public MapConfig Config { get; }

		public MapLifecycleHooks Hooks { get; }

		public CustomMap(AssetBundle bundle, string sceneName, string displayName, string mapId, MapConfig? config = null, MapLifecycleHooks? hooks = null)
		{
			Bundle = bundle;
			SceneName = sceneName;
			DisplayName = displayName;
			MapId = mapId;
			Config = config ?? new MapConfig();
			Hooks = hooks ?? new MapLifecycleHooks();
		}
	}
	public static class Maps
	{
		public static CustomMap RegisterMap(AssetBundle bundle, string sceneName, string displayName, MapConfig? config = null, string? mapId = null, MapLifecycleHooks? hooks = null)
		{
			CustomMap customMap = RegisterMapCore(bundle, sceneName, displayName, config, mapId, hooks);
			if (customMap == null)
			{
				throw new InvalidOperationException("[Maps] Failed to register map '" + displayName + "'.");
			}
			return customMap;
		}

		public static CustomMap? TryRegisterMap(AssetBundle bundle, string sceneName, string displayName, MapConfig? config = null, string? mapId = null, MapLifecycleHooks? hooks = null)
		{
			return RegisterMapCore(bundle, sceneName, displayName, config, mapId, hooks);
		}

		private static CustomMap? RegisterMapCore(AssetBundle bundle, string sceneName, string displayName, MapConfig? config, string? mapId, MapLifecycleHooks? hooks)
		{
			string mapId2 = (string.IsNullOrWhiteSpace(mapId) ? SanitizeMapId(displayName) : mapId.Trim());
			CustomMap customMap = new CustomMap(bundle, sceneName, displayName, mapId2, config, hooks);
			if (!DbsContentApiPlugin.RegisterCustomMap(customMap))
			{
				return null;
			}
			return customMap;
		}

		public static bool TryGetMap(string mapId, out CustomMap? map)
		{
			return DbsContentApiPlugin.TryGetCustomMap(mapId, out map);
		}

		public static bool TryGetMapByIndex(int index, out CustomMap? map)
		{
			return DbsContentApiPlugin.TryGetCustomMapByIndex(index, out map);
		}

		public static IReadOnlyList<CustomMap> GetRegisteredMaps()
		{
			return DbsContentApiPlugin.customMaps;
		}

		public static void ForceNextMap(string mapId)
		{
			DbsContentApiPlugin.forcedNextMapId = mapId;
			ApiLog.Log("[Maps] Next map selection forced to: " + mapId);
		}

		public static void ClearForcedMap()
		{
			DbsContentApiPlugin.forcedNextMapId = null;
		}

		public static void SetSelectedMapId(string? mapId)
		{
			DbsContentApiPlugin.selectedCustomMapId = mapId;
		}

		public static int GetLevelIndexForMap(CustomMap map)
		{
			int num = DbsContentApiPlugin.customMaps.IndexOf(map);
			if (num >= 0)
			{
				return 3 + num;
			}
			return -1;
		}

		public static string? FindScenePath(AssetBundle bundle, string hint)
		{
			return bundle.GetAllScenePaths().FirstOrDefault((string p) => p.Contains(hint, StringComparison.OrdinalIgnoreCase));
		}

		public static string SanitizeMapId(string displayName)
		{
			if (string.IsNullOrWhiteSpace(displayName))
			{
				return "map.unnamed";
			}
			char[] value = (from c in displayName.Trim().ToLowerInvariant()
				select (!char.IsLetterOrDigit(c)) ? '_' : c).ToArray();
			string text = new string(value).Trim('_');
			while (text.Contains("__", StringComparison.Ordinal))
			{
				text = text.Replace("__", "_", StringComparison.Ordinal);
			}
			if (!string.IsNullOrEmpty(text))
			{
				return text;
			}
			return "map.unnamed";
		}

		internal static CustomMap? ResolveMapForCurrentRound()
		{
			if (!string.IsNullOrEmpty(DbsContentApiPlugin.selectedCustomMapId) && TryGetMap(DbsContentApiPlugin.selectedCustomMapId, out CustomMap map) && map != null)
			{
				return map;
			}
			int index = SurfaceNetworkHandler.RoomStats.LevelToPlay - 3;
			if (!TryGetMapByIndex(index, out CustomMap map2))
			{
				return null;
			}
			return map2;
		}

		internal static CustomMap? PickMapForNextRound(RoomStatsHolder roomStats)
		{
			if (DbsContentApiPlugin.customMaps.Count == 0)
			{
				return null;
			}
			string forcedNextMapId = DbsContentApiPlugin.forcedNextMapId;
			DbsContentApiPlugin.forcedNextMapId = null;
			if (!string.IsNullOrEmpty(forcedNextMapId))
			{
				if (TryGetMap(forcedNextMapId, out CustomMap map) && map != null)
				{
					return map;
				}
				ApiLog.LogError("[Maps] Forced map id '" + forcedNextMapId + "' not found.");
			}
			int num = 3 + DbsContentApiPlugin.customMaps.Count;
			int num2 = (DbsContentApiPlugin.moddedMapsOnly ? 3 : 0);
			int num3 = Random.Range(num2, num);
			for (int i = 0; i < 100; i++)
			{
				if (!DbsContentApiPlugin.moddedMapsOnly && num3 < 3)
				{
					return null;
				}
				int num4 = num3 - 3;
				if (num4 >= 0 && num4 < DbsContentApiPlugin.customMaps.Count)
				{
					CustomMap customMap = DbsContentApiPlugin.customMaps[num4];
					if (GetLevelIndexForMap(customMap) != roomStats.LevelToPlay || DbsContentApiPlugin.customMaps.Count == 1)
					{
						return customMap;
					}
				}
				num3 = Random.Range(num2, num);
			}
			return DbsContentApiPlugin.customMaps[0];
		}
	}
	public class CustomMapLoader : MonoBehaviour
	{
		private struct PatrolPointEntry
		{
			public PatrolPoint Point;

			public HashSet<PatrolGroup> Groups;
		}

		private readonly List<PatrolPointEntry> _patrolEntries = new List<PatrolPointEntry>();

		public static float multiplierMonster = 1f;

		public static float multiplierTool = 1f;

		public static float multiplierArtifact = 1f;

		public CustomMap? Map { get; set; }

		private IEnumerator Start()
		{
			if (Map == null)
			{
				ApiLog.LogError("CustomMapLoader: Map is null!");
				yield break;
			}
			MapConfig config = Map.Config;
			MapPipelineFlags pipeline = config.pipeline;
			MapLoadContext ctx = new MapLoadContext(Map, this);
			multiplierMonster = 1f;
			multiplierTool = 1f;
			multiplierArtifact = 1f;
			if (SurfaceNetworkHandler.RoomStats.LevelToPlay < 3)
			{
				ApiLog.Log($"[Maps] LevelToPlay ({SurfaceNetworkHandler.RoomStats.LevelToPlay}) is vanilla. Enabling occlusion culling and exiting loader.");
				Camera.main.useOcclusionCulling = true;
				yield break;
			}
			ApiLog.Log("[Maps] Loading custom map: " + Map.DisplayName + " (Id: " + Map.MapId + ", Scene: " + Map.SceneName + ")");
			Camera.main.useOcclusionCulling = false;
			_patrolEntries.Clear();
			ctx.ActiveScene = SceneManager.GetActiveScene();
			DivingBell tmp = Object.FindObjectOfType<DivingBell>();
			if ((Object)(object)tmp == (Object)null)
			{
				ApiLog.LogError("[Maps] DivingBell not found in scene!");
				yield break;
			}
			Material bellMaterial = GetDivingBellMaterial(tmp);
			if ((Object)(object)bellMaterial == (Object)null)
			{
				yield break;
			}
			tmp.locked = true;
			Map.Hooks.onBeforeCleanup?.Invoke(ctx);
			if (!pipeline.skipVanillaCleanup)
			{
				RunVanillaCleanup(config);
			}
			ApiLog.Log("[Maps] Asynchronously loading scene: " + Map.SceneName);
			AsyncOperation val = SceneManager.LoadSceneAsync(Map.SceneName, (LoadSceneMode)1);
			if (val == null)
			{
				ApiLog.LogError("[Maps] Failed to start loading scene: " + Map.SceneName);
				yield break;
			}
			yield return val;
			for (int i = 0; i < SceneManager.sceneCount; i++)
			{
				Scene sceneAt = SceneManager.GetSceneAt(i);
				if (((Scene)(ref sceneAt)).path == Map.SceneName || ((Scene)(ref sceneAt)).name == Path.GetFileNameWithoutExtension(Map.SceneName))
				{
					ctx.LoadedScene = sceneAt;
					break;
				}
			}
			ApiLog.Log("[Maps] Scene loaded: " + Map.SceneName);
			Map.Hooks.onAfterSceneLoaded?.Invoke(ctx);
			if (!pipeline.skipRetexture && config.retextureScene)
			{
				RetextureScene(config, bellMaterial);
			}
			CollectMarkers(config, ctx);
			if (!pipeline.skipPatrolSetup && config.setupPatrolPoints)
			{
				SetupPatrolPoints(config, ctx);
			}
			if (!pipeline.skipMonsterRemoval && config.applyMonsterRemoval)
			{
				ApplyMonsterRemoval(config);
			}
			if (!pipeline.skipMultipliers && config.setupMultipliers)
			{
				LoadMultipliers(config);
			}
			if (!pipeline.skipAmbience && config.setupAmbience)
			{
				SetupAmbience(config);
			}
			Map.Hooks.onAfterSetup?.Invoke(ctx);
			if (!pipeline.skipFinalize)
			{
				bool shouldRebootPlayer = false;
				Vector3 playerSpawnPosition = Vector3.zero;
				Quaternion playerSpawnRotation = Quaternion.identity;
				if (!pipeline.skipDiveBellTeleport)
				{
					shouldRebootPlayer = TryTeleportToSpawn(tmp, ctx, out playerSpawnPosition, out playerSpawnRotation);
				}
				ApiLog.Log("[Maps] Waiting for all players to join...");
				while (PhotonNetwork.PlayerList.Length != PlayerHandler.instance.players.Count)
				{
					yield return null;
				}
				yield return null;
				ApiLog.Log("[Maps] Map setup complete. Level is ready.");
				Level.currentLevel.levelIsReady = true;
				tmp.locked = false;
				if (shouldRebootPlayer)
				{
					RebootLocalPlayerAfterMapLoad(playerSpawnPosition, playerSpawnRotation);
				}
				MethodInfo method = typeof(Level).GetMethod("SetupFinished", BindingFlags.Instanc