using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Discord.Sdk;
using ExitGames.Client.Photon;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using Steamworks;
using Steamworks.Data;
using TMPro;
using UnityEngine;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("")]
[assembly: AssemblyCompany("REPOJP")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("zabuMod")]
[assembly: AssemblyTitle("zabuMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace REPOJPAllMapMerge
{
	[BepInPlugin("REPOJP.AllMapMerge", "AllMapMerge", "2.0.1")]
	public class Plugin : BaseUnityPlugin
	{
		private class RoomEntry
		{
			public PrefabRef PrefabRef;

			public Level SourceLevel;

			public RoomEntry(PrefabRef prefabRef, Level sourceLevel)
			{
				PrefabRef = prefabRef;
				SourceLevel = sourceLevel;
			}
		}

		private class CategoryUsage
		{
			public readonly HashSet<string> UsedPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
		}

		private class CategoryPool
		{
			public readonly List<RoomEntry> Entries = new List<RoomEntry>();

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

			public int UniqueCount => uniquePaths.Count;

			public void Add(RoomEntry entry)
			{
				if (entry != null && entry.PrefabRef != null)
				{
					Entries.Add(entry);
					uniquePaths.Add(entry.PrefabRef.ResourcePath);
				}
			}

			public bool ContainsResourcePath(string resourcePath)
			{
				if (string.IsNullOrEmpty(resourcePath))
				{
					return false;
				}
				return uniquePaths.Contains(resourcePath);
			}

			public RoomEntry ChoosePreferDifferentSource(HashSet<Level> avoidSourceLevels, CategoryUsage usage, RoomEntry currentEntry)
			{
				if (Entries.Count <= 0)
				{
					return null;
				}
				if (NoRepeatUntilPoolExhausted.Value && usage != null && usage.UsedPaths.Count >= UniqueCount)
				{
					usage.UsedPaths.Clear();
				}
				List<RoomEntry> list = BuildCandidateList(avoidSourceLevels, usage, enforceAvoidSources: true);
				if (list.Count <= 0)
				{
					list = BuildCandidateList(avoidSourceLevels, usage, enforceAvoidSources: false);
				}
				if (list.Count <= 0)
				{
					list = BuildCandidateList(null, usage, enforceAvoidSources: true);
				}
				if (list.Count <= 0)
				{
					list = new List<RoomEntry>(Entries);
				}
				if (currentEntry != null)
				{
					int num = CalculateConflictScore(currentEntry, avoidSourceLevels);
					List<RoomEntry> list2 = new List<RoomEntry>();
					for (int i = 0; i < list.Count; i++)
					{
						RoomEntry roomEntry = list[i];
						if (roomEntry != null && CalculateConflictScore(roomEntry, avoidSourceLevels) < num)
						{
							list2.Add(roomEntry);
						}
					}
					if (list2.Count <= 0)
					{
						return currentEntry;
					}
					list = list2;
				}
				RoomEntry roomEntry2 = list[Random.Range(0, list.Count)];
				if (roomEntry2 != null && usage != null && NoRepeatUntilPoolExhausted.Value && !string.IsNullOrEmpty(roomEntry2.PrefabRef.ResourcePath))
				{
					usage.UsedPaths.Add(roomEntry2.PrefabRef.ResourcePath);
				}
				return roomEntry2;
			}

			private List<RoomEntry> BuildCandidateList(HashSet<Level> avoidSourceLevels, CategoryUsage usage, bool enforceAvoidSources)
			{
				List<RoomEntry> list = new List<RoomEntry>();
				for (int i = 0; i < Entries.Count; i++)
				{
					RoomEntry roomEntry = Entries[i];
					if (roomEntry != null && roomEntry.PrefabRef != null && (!enforceAvoidSources || avoidSourceLevels == null || avoidSourceLevels.Count <= 0 || !((Object)(object)roomEntry.SourceLevel != (Object)null) || !avoidSourceLevels.Contains(roomEntry.SourceLevel)) && (!NoRepeatUntilPoolExhausted.Value || usage == null || !usage.UsedPaths.Contains(roomEntry.PrefabRef.ResourcePath)))
					{
						list.Add(roomEntry);
					}
				}
				return list;
			}

			private int CalculateConflictScore(RoomEntry entry, HashSet<Level> avoidSourceLevels)
			{
				if (entry == null || (Object)(object)entry.SourceLevel == (Object)null || avoidSourceLevels == null || avoidSourceLevels.Count <= 0)
				{
					return 0;
				}
				return avoidSourceLevels.Contains(entry.SourceLevel) ? 1 : 0;
			}
		}

		private class MergedPools
		{
			public List<Level> SourceLevels = new List<Level>();

			public CategoryPool StartRooms = new CategoryPool();

			public CategoryPool NormalRooms = new CategoryPool();

			public CategoryPool PassageRooms = new CategoryPool();

			public CategoryPool DeadEndRooms = new CategoryPool();

			public CategoryPool ExtractionRooms = new CategoryPool();
		}

		[HarmonyPatch(typeof(LevelGenerator), "StartRoomGeneration")]
		private static class Patch_LevelGenerator_StartRoomGeneration
		{
			private static bool Prefix(LevelGenerator __instance, ref IEnumerator __result)
			{
				if (!ShouldApply(__instance.Level))
				{
					return true;
				}
				__result = StartRoomGenerationOverride(__instance);
				return false;
			}
		}

		[HarmonyPatch(typeof(LevelGenerator), "ModuleGeneration")]
		private static class Patch_LevelGenerator_ModuleGeneration
		{
			private static bool Prefix(LevelGenerator __instance, ref IEnumerator __result)
			{
				if (!ShouldApply(__instance.Level))
				{
					return true;
				}
				__result = ModuleGenerationOverride(__instance);
				return false;
			}
		}

		[HarmonyPatch(typeof(ValuableDirector), "SetupHost")]
		private static class Patch_ValuableDirector_SetupHost
		{
			private static void Prefix()
			{
				Level baseLevel = (((Object)(object)LevelGenerator.Instance != (Object)null) ? LevelGenerator.Instance.Level : null);
				PrepareMergedValuablePresets(baseLevel);
			}
		}

		[HarmonyPatch(typeof(RunManager), "SetRunLevel")]
		private static class Patch_RunManager_SetRunLevel
		{
			private static void Postfix(RunManager __instance)
			{
				try
				{
					if ((Object)(object)__instance == (Object)null || !Enabled.Value)
					{
						return;
					}
					Level levelCurrent = __instance.levelCurrent;
					if ((Object)(object)levelCurrent == (Object)null || IsAlwaysExcludedLevel(levelCurrent) || !IsSafeTargetVanillaLevel(levelCurrent) || IsForcedMuseumBaseLevel(levelCurrent))
					{
						return;
					}
					Level val = ResolveForcedMuseumBaseLevel();
					if (!((Object)(object)val == (Object)null))
					{
						__instance.levelCurrent = val;
						if (DebugLog.Value && LogSource != null)
						{
							string text = "Forced base level from " + SafeLevelName(levelCurrent) + " to " + SafeLevelName(val);
							LogSource.LogInfo((object)text);
						}
					}
				}
				catch (Exception ex)
				{
					if (LogSource != null)
					{
						LogSource.LogError((object)("RunManager SetRunLevel museum force failed\n" + ex));
					}
				}
			}
		}

		[HarmonyPatch(typeof(RunManager), "UpdateSteamRichPresence")]
		private static class Patch_RunManager_UpdateSteamRichPresence
		{
			private static bool Prefix(RunManager __instance)
			{
				UpdateRoomMergedMapActiveProperty();
				if (!ShouldOverrideRichPresence())
				{
					return true;
				}
				int num = DataDirector.instance.SettingValueFetch((Setting)59);
				string text = "In Menu";
				string text2 = GetMergedMapPresenceName();
				if ((Object)(object)__instance.levelCurrent == (Object)(object)__instance.levelMainMenu || (Object)(object)__instance.levelCurrent == (Object)(object)__instance.levelSplashScreen || SemiFunc.RunIsTutorial() || SemiFunc.RunIsLobbyMenu())
				{
					SteamFriends.SetRichPresence("levelname", num switch
					{
						2 => GetMergedMapPresenceName(), 
						1 => text, 
						_ => null, 
					});
					SteamFriends.SetRichPresence("levelnum", (string)null);
					SteamFriends.SetRichPresence("steam_display", "#Status_LevelName");
				}
				else
				{
					string text3 = (StatsManager.instance.GetRunStatLevel() + 1).ToString();
					text = ((num == 1) ? "In Game" : (SemiFunc.RunIsArena() ? "In Arena" : (SemiFunc.RunIsLobby() ? "In Truck" : (SemiFunc.RunIsShop() ? "In Shop" : "In Game"))));
					text2 = "Level " + text3 + " - " + GetMergedMapPresenceName();
					SteamFriends.SetRichPresence("levelname", num switch
					{
						2 => GetMergedMapPresenceName(), 
						1 => text, 
						_ => null, 
					});
					SteamFriends.SetRichPresence("levelnum", (num == 2) ? text3 : null);
					SteamFriends.SetRichPresence("steam_display", (num == 2) ? "#Status_LevelNameNum" : "#Status_LevelName");
				}
				DiscordManager instance = DiscordManager.instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.UpdateDiscordRichPresence(text, text2);
				}
				return false;
			}
		}

		[HarmonyPatch(typeof(DiscordManager), "RefreshDiscordRichPresence")]
		private static class Patch_DiscordManager_RefreshDiscordRichPresence
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static UpdateRichPresenceCallback <>9__3_1;

				public static UpdateRichPresenceCallback <>9__3_0;

				internal void <Prefix>b__3_1(ClientResult result)
				{
				}

				internal void <Prefix>b__3_0(ClientResult result)
				{
				}
			}

			private static readonly FieldRef<DiscordManager, Client> ClientRef = AccessTools.FieldRefAccess<DiscordManager, Client>("client");

			private static readonly FieldRef<DiscordManager, Activity> ActivityRef = AccessTools.FieldRefAccess<DiscordManager, Activity>("activity");

			private static readonly FieldRef<DiscordManager, ActivityParty> ActivityPartyRef = AccessTools.FieldRefAccess<DiscordManager, ActivityParty>("activityParty");

			private static bool Prefix(DiscordManager __instance)
			{
				//IL_0052: Unknown result type (might be due to invalid IL or missing references)
				//IL_0058: Expected O, but got Unknown
				//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ed: Expected O, but got Unknown
				//IL_0163: Unknown result type (might be due to invalid IL or missing references)
				//IL_016a: Expected O, but got Unknown
				//IL_0176: Unknown result type (might be due to invalid IL or missing references)
				//IL_017b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bb: Expected O, but got Unknown
				if (!ShouldOverrideRichPresence())
				{
					return true;
				}
				Client val = ClientRef.Invoke(__instance);
				Activity val2 = ActivityRef.Invoke(__instance);
				ActivityParty val3 = ActivityPartyRef.Invoke(__instance);
				if (val == null)
				{
					return true;
				}
				ActivityAssets val4 = new ActivityAssets();
				switch (DataDirector.instance.SettingValueFetch((Setting)59))
				{
				case 1:
				{
					val2.SetDetails((string)null);
					val4.SetLargeImage("taxman");
					ActivityAssets val7 = val4;
					BuildManager instance = BuildManager.instance;
					val7.SetLargeText(((Object)(object)instance != (Object)null) ? instance.version.title : null);
					val2.SetAssets(val4);
					val2.SetParty((ActivityParty)null);
					val2.SetSecrets((ActivitySecrets)null);
					object obj3 = <>c.<>9__3_1;
					if (obj3 == null)
					{
						UpdateRichPresenceCallback val8 = delegate
						{
						};
						<>c.<>9__3_1 = val8;
						obj3 = (object)val8;
					}
					val.UpdateRichPresence(val2, (UpdateRichPresenceCallback)obj3);
					ActivityRef.Invoke(__instance) = val2;
					return false;
				}
				default:
					val.ClearRichPresence();
					return false;
				case 2:
				{
					val4.SetLargeImage(GetMergedMapDiscordLargeImageKey());
					val4.SetLargeText(GetMergedMapPresenceName());
					val2.SetAssets(val4);
					val2.SetParty(val3);
					ActivitySecrets val5 = null;
					if (val3 != null && SemiFunc.RunIsLobbyMenu())
					{
						val5 = new ActivitySecrets();
						ActivitySecrets obj = val5;
						SteamId id = ((Lobby)(ref SteamManager.instance.currentLobby)).Id;
						obj.SetJoin(((object)(SteamId)(ref id)).ToString());
					}
					val2.SetSecrets(val5);
					object obj2 = <>c.<>9__3_0;
					if (obj2 == null)
					{
						UpdateRichPresenceCallback val6 = delegate
						{
						};
						<>c.<>9__3_0 = val6;
						obj2 = (object)val6;
					}
					val.UpdateRichPresence(val2, (UpdateRichPresenceCallback)obj2);
					ActivityRef.Invoke(__instance) = val2;
					return false;
				}
				}
			}
		}

		[HarmonyPatch(typeof(LoadingUI), "LevelAnimationStart")]
		private static class Patch_LoadingUI_LevelAnimationStart
		{
			private static void Postfix(LoadingUI __instance)
			{
				try
				{
					if ((Object)(object)__instance == (Object)null || (Object)(object)LevelGenerator.Instance == (Object)null || (Object)(object)LevelGenerator.Instance.Level == (Object)null)
					{
						return;
					}
					UpdateRoomMergedMapActiveProperty();
					if (!ShouldApplyClientVisuals(LevelGenerator.Instance.Level))
					{
						return;
					}
					LogLoadingGraphicCandidateNames(__instance, LevelGenerator.Instance.Level);
					if (!((Object)(object)CustomLoadingOverrideSprite == (Object)null))
					{
						ReplaceMatchedLoadingImage(__instance.loadingGraphic01, LevelGenerator.Instance.Level.LoadingGraphic01);
						ReplaceMatchedLoadingImage(__instance.loadingGraphic02, LevelGenerator.Instance.Level.LoadingGraphic02);
						ReplaceMatchedLoadingImage(__instance.loadingGraphic03, LevelGenerator.Instance.Level.LoadingGraphic03);
						if ((Object)(object)__instance.levelNameText != (Object)null)
						{
							((TMP_Text)__instance.levelNameText).text = GetMergedMapPresenceName();
						}
					}
				}
				catch (Exception ex)
				{
					if (LogSource != null)
					{
						LogSource.LogError((object)("Loading texture replace failed\n" + ex));
					}
				}
			}
		}

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

			private object <>2__current;

			public LevelGenerator generator;

			private MergedPools <pools>5__1;

			private Tile[,] <levelGrid>5__2;

			private int <width>5__3;

			private int <height>5__4;

			private RoomEntry[,] <plannedEntries>5__5;

			private Type[,] <plannedTypes>5__6;

			private CategoryUsage <normalUsage>5__7;

			private CategoryUsage <passageUsage>5__8;

			private CategoryUsage <deadEndUsage>5__9;

			private CategoryUsage <extractionUsage>5__10;

			private int <x>5__11;

			private int <y>5__12;

			private Tile <tile>5__13;

			private Type <targetType>5__14;

			private HashSet<Level> <avoidSources>5__15;

			private CategoryPool <targetPool>5__16;

			private CategoryUsage <targetUsage>5__17;

			private RoomEntry <chosenEntry>5__18;

			private int <x>5__19;

			private int <y>5__20;

			private Tile <tile>5__21;

			private Vector3 <position>5__22;

			private Type <targetType>5__23;

			private Vector3 <rotation>5__24;

			private RoomEntry <chosenEntry>5__25;

			private CategoryPool <fallbackPool>5__26;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<pools>5__1 = null;
				<levelGrid>5__2 = null;
				<plannedEntries>5__5 = null;
				<plannedTypes>5__6 = null;
				<normalUsage>5__7 = null;
				<passageUsage>5__8 = null;
				<deadEndUsage>5__9 = null;
				<extractionUsage>5__10 = null;
				<tile>5__13 = null;
				<avoidSources>5__15 = null;
				<targetPool>5__16 = null;
				<targetUsage>5__17 = null;
				<chosenEntry>5__18 = null;
				<tile>5__21 = null;
				<chosenEntry>5__25 = null;
				<fallbackPool>5__26 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0426: Unknown result type (might be due to invalid IL or missing references)
				//IL_042b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0443: Unknown result type (might be due to invalid IL or missing references)
				//IL_0448: Unknown result type (might be due to invalid IL or missing references)
				//IL_0467: Unknown result type (might be due to invalid IL or missing references)
				//IL_046c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0471: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_04c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_0217: Unknown result type (might be due to invalid IL or missing references)
				//IL_021c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0252: Unknown result type (might be due to invalid IL or missing references)
				//IL_0263: Unknown result type (might be due to invalid IL or missing references)
				//IL_0298: Unknown result type (might be due to invalid IL or missing references)
				//IL_051c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0522: Unknown result type (might be due to invalid IL or missing references)
				//IL_0528: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				if (num != 0)
				{
					if (num != 1)
					{
						return false;
					}
					<>1__state = -1;
					<tile>5__21 = null;
					<chosenEntry>5__25 = null;
					goto IL_055f;
				}
				<>1__state = -1;
				WaitingForSubCoroutineRef.Invoke(generator) = true;
				generator.State = (LevelState)5;
				UpdateRoomMergedMapActiveProperty();
				<pools>5__1 = BuildMergedPools(generator.Level);
				if (<pools>5__1.NormalRooms.UniqueCount <= 0)
				{
					<pools>5__1 = BuildCurrentLevelPools(generator.Level);
				}
				if (<pools>5__1.NormalRooms.UniqueCount <= 0)
				{
					WaitingForSubCoroutineRef.Invoke(generator) = false;
					return false;
				}
				PassageAmountRef.Invoke(generator) = 0;
				<levelGrid>5__2 = LevelGridRef.Invoke(generator);
				if (<levelGrid>5__2 == null)
				{
					WaitingForSubCoroutineRef.Invoke(generator) = false;
					return false;
				}
				<width>5__3 = generator.LevelWidth;
				<height>5__4 = generator.LevelHeight;
				<plannedEntries>5__5 = new RoomEntry[<width>5__3, <height>5__4];
				<plannedTypes>5__6 = new Type[<width>5__3, <height>5__4];
				<normalUsage>5__7 = new CategoryUsage();
				<passageUsage>5__8 = new CategoryUsage();
				<deadEndUsage>5__9 = new CategoryUsage();
				<extractionUsage>5__10 = new CategoryUsage();
				<x>5__11 = 0;
				while (<x>5__11 < <width>5__3)
				{
					<y>5__12 = 0;
					while (<y>5__12 < <height>5__4)
					{
						<tile>5__13 = <levelGrid>5__2[<x>5__11, <y>5__12];
						if (<tile>5__13 != null && <tile>5__13.active)
						{
							<targetType>5__14 = ResolveTargetModuleType(generator, <levelGrid>5__2, <x>5__11, <y>5__12);
							<plannedTypes>5__6[<x>5__11, <y>5__12] = <targetType>5__14;
							<avoidSources>5__15 = CollectAdjacentSourceLevels(<plannedEntries>5__5, <width>5__3, <height>5__4, <x>5__11, <y>5__12);
							<targetPool>5__16 = GetPoolForType(<pools>5__1, <targetType>5__14);
							<targetUsage>5__17 = GetUsageForType(<targetType>5__14, <normalUsage>5__7, <passageUsage>5__8, <deadEndUsage>5__9, <extractionUsage>5__10);
							<chosenEntry>5__18 = ChooseRoomEntry(<targetPool>5__16, <pools>5__1, <targetType>5__14, <avoidSources>5__15, <targetUsage>5__17);
							<plannedEntries>5__5[<x>5__11, <y>5__12] = <chosenEntry>5__18;
							<tile>5__13 = null;
							<avoidSources>5__15 = null;
							<targetPool>5__16 = null;
							<targetUsage>5__17 = null;
							<chosenEntry>5__18 = null;
						}
						<y>5__12++;
					}
					<x>5__11++;
				}
				OptimizePlannedEntries(<levelGrid>5__2, <plannedEntries>5__5, <plannedTypes>5__6, <pools>5__1, <width>5__3, <height>5__4);
				<x>5__19 = 0;
				goto IL_059b;
				IL_055f:
				<y>5__20++;
				goto IL_0571;
				IL_0571:
				if (<y>5__20 < <height>5__4)
				{
					<tile>5__21 = <levelGrid>5__2[<x>5__19, <y>5__20];
					if (<tile>5__21 != null && <tile>5__21.active)
					{
						<position>5__22 = new Vector3((float)<x>5__19 * LevelGenerator.ModuleWidth * LevelGenerator.TileSize - (float)(generator.LevelWidth / 2) * LevelGenerator.ModuleWidth * LevelGenerator.TileSize, 0f, (float)<y>5__20 * LevelGenerator.ModuleWidth * LevelGenerator.TileSize + LevelGenerator.ModuleWidth * LevelGenerator.TileSize / 2f);
						<targetType>5__23 = <plannedTypes>5__6[<x>5__19, <y>5__20];
						<rotation>5__24 = ResolveRotation(generator, <levelGrid>5__2, <x>5__19, <y>5__20, <targetType>5__23);
						<chosenEntry>5__25 = <plannedEntries>5__5[<x>5__19, <y>5__20];
						if (<chosenEntry>5__25 == null)
						{
							<fallbackPool>5__26 = GetPoolForType(<pools>5__1, <targetType>5__23);
							<chosenEntry>5__25 = ChooseRoomEntry(<fallbackPool>5__26, <pools>5__1, <targetType>5__23, null, null);
							<fallbackPool>5__26 = null;
						}
						if (<chosenEntry>5__25 != null && <chosenEntry>5__25.PrefabRef != null)
						{
							SpawnMergedModule(generator, <levelGrid>5__2, <x>5__19, <y>5__20, <position>5__22, <rotation>5__24, <targetType>5__23, <chosenEntry>5__25);
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
					}
					goto IL_055f;
				}
				<x>5__19++;
				goto IL_059b;
				IL_059b:
				if (<x>5__19 < <width>5__3)
				{
					<y>5__20 = 0;
					goto IL_0571;
				}
				WaitingForSubCoroutineRef.Invoke(generator) = false;
				return false;
			}

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

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

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

			private object <>2__current;

			public LevelGenerator generator;

			private MergedPools <pools>5__1;

			private CategoryPool <startPool>5__2;

			private RoomEntry <chosenEntry>5__3;

			private GameObject <roomObject>5__4;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<pools>5__1 = null;
				<startPool>5__2 = null;
				<chosenEntry>5__3 = null;
				<roomObject>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_016d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0172: Unknown result type (might be due to invalid IL or missing references)
				//IL_0144: Unknown result type (might be due to invalid IL or missing references)
				//IL_0149: Unknown result type (might be due to invalid IL or missing references)
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					WaitingForSubCoroutineRef.Invoke(generator) = true;
					generator.State = (LevelState)3;
					UpdateRoomMergedMapActiveProperty();
					<pools>5__1 = BuildMergedPools(generator.Level);
					<startPool>5__2 = ((RandomizeStartRooms.Value && <pools>5__1.StartRooms.UniqueCount > 0) ? <pools>5__1.StartRooms : BuildCurrentLevelStartPool(generator.Level));
					if (<startPool>5__2 == null || <startPool>5__2.UniqueCount <= 0)
					{
						WaitingForSubCoroutineRef.Invoke(generator) = false;
						return false;
					}
					<chosenEntry>5__3 = <startPool>5__2.ChoosePreferDifferentSource(null, null, null);
					if (<chosenEntry>5__3 == null || <chosenEntry>5__3.PrefabRef == null)
					{
						WaitingForSubCoroutineRef.Invoke(generator) = false;
						return false;
					}
					<roomObject>5__4 = null;
					if (GameManager.instance.gameMode == 0)
					{
						<roomObject>5__4 = Object.Instantiate<GameObject>(<chosenEntry>5__3.PrefabRef.Prefab, Vector3.zero, Quaternion.identity);
					}
					else
					{
						<roomObject>5__4 = PhotonNetwork.InstantiateRoomObject(<chosenEntry>5__3.PrefabRef.ResourcePath, Vector3.zero, Quaternion.identity, (byte)0, (object[])null);
					}
					if ((Object)(object)<roomObject>5__4 != (Object)null && (Object)(object)generator.LevelParent != (Object)null)
					{
						<roomObject>5__4.transform.parent = generator.LevelParent.transform;
					}
					if (DebugLog.Value)
					{
						LogSource.LogInfo((object)("Merged start room selected: " + <chosenEntry>5__3.PrefabRef.ResourcePath + " / SourceLevel=" + SafeLevelName(<chosenEntry>5__3.SourceLevel)));
					}
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					WaitingForSubCoroutineRef.Invoke(generator) = false;
					return false;
				}
			}

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

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

		public const string PluginGuid = "REPOJP.AllMapMerge";

		public const string PluginName = "AllMapMerge";

		public const string PluginVersion = "2.0.1";

		internal const string MergedMapPresenceName = "AllMapMerge";

		internal const string MergedMapDiscordLargeImageKey = "allmapmerge";

		internal const string CustomLoadingOverrideFileName = "AllMapMerge.png";

		internal const string RoomPropertyMergedMapActiveKey = "REPOJP_AllMapMerge_Active";

		internal static readonly string[] TargetLoadingTextureNames = new string[4] { "level arctic 01", "level wizard 01", "level museum 01", "level manor 01" };

		internal static readonly string[] SafeMergedVanillaLevelNames = new string[4] { "arctic", "wizard", "museum", "manor" };

		internal const string ForcedBaseLevelNameMuseum = "museum";

		internal const string ForcedBaseLevelTextureMuseum = "level museum 01";

		internal static Sprite CustomLoadingOverrideSprite;

		internal static Plugin Instance;

		internal static ManualLogSource LogSource;

		internal static ConfigEntry<bool> Enabled;

		internal static ConfigEntry<bool> DangerousEnableAllMapsMergeIncludingModdedMapsCanBreakMaps;

		internal static ConfigEntry<bool> RandomizeStartRooms;

		internal static ConfigEntry<bool> FullyRandomIgnoreDifficultyTier;

		internal static ConfigEntry<bool> NoRepeatUntilPoolExhausted;

		internal static ConfigEntry<bool> PreferDifferentAdjacentSourceLevel;

		internal static ConfigEntry<int> AdjacencyImprovePasses;

		internal static ConfigEntry<bool> DebugLog;

		internal static ConfigEntry<bool> LogLoadingGraphicNames;

		internal static ConfigEntry<string> ExcludedRoomResourcePaths;

		private static readonly Dictionary<Level, List<LevelValuables>> OriginalValuablePresetsByLevel = new Dictionary<Level, List<LevelValuables>>();

		private Harmony harmony;

		private static readonly FieldRef<LevelGenerator, bool> WaitingForSubCoroutineRef = AccessTools.FieldRefAccess<LevelGenerator, bool>("waitingForSubCoroutine");

		private static readonly FieldRef<LevelGenerator, int> PassageAmountRef = AccessTools.FieldRefAccess<LevelGenerator, int>("PassageAmount");

		private static readonly FieldRef<LevelGenerator, Tile[,]> LevelGridRef = AccessTools.FieldRefAccess<LevelGenerator, Tile[,]>("LevelGrid");

		private static readonly FieldRef<LevelGenerator, Vector3[]> ModuleRotationsRef = AccessTools.FieldRefAccess<LevelGenerator, Vector3[]>("ModuleRotations");

		private static readonly FieldRef<Module, int> GridXRef = AccessTools.FieldRefAccess<Module, int>("GridX");

		private static readonly FieldRef<Module, int> GridYRef = AccessTools.FieldRefAccess<Module, int>("GridY");

		private void Awake()
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			try
			{
				Instance = this;
				LogSource = ((BaseUnityPlugin)this).Logger;
				((Component)this).transform.parent = null;
				((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
				Enabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enabled", true, "Enable merged-map generation.AllMapMergeを有効化");
				DangerousEnableAllMapsMergeIncludingModdedMapsCanBreakMaps = ((BaseUnityPlugin)this).Config.Bind<bool>("Danger", "!!!DANGER_EnableAllMapsMergeIncludingModdedMaps_CanBreakMaps", false, "Recommended OFF.OFFが通常動作です ONにすると追加マップを含む全ての対象可能マップでマージを有効化し さらに追加マップを含む全ての対象可能マップの部屋をソースとして使用します 互換性崩壊や進行不能や表示崩れの可能性があります");
				RandomizeStartRooms = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "RandomizeStartRooms", true, "Pick start rooms from the merged start-room pool.統合された開始部屋プールから開始部屋を選択");
				FullyRandomIgnoreDifficultyTier = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "FullyRandomIgnoreDifficultyTier", true, "Ignore difficulty tiers and merge 1/2/3 pools into one pool per category.難易度帯を無視して各カテゴリの1/2/3プールを1つに統合");
				NoRepeatUntilPoolExhausted = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "NoRepeatUntilPoolExhausted", false, "Do not repeat the same room in a category until its merged pool has been exhausted.カテゴリ内で統合プールを使い切るまで同じ部屋を再利用しない");
				PreferDifferentAdjacentSourceLevel = ((BaseUnityPlugin)this).Config.Bind<bool>("Generation", "PreferDifferentAdjacentSourceLevel", true, "Prefer a different source map than already planned adjacent rooms when possible.可能な限り隣接済み部屋と別の出典マップを優先");
				AdjacencyImprovePasses = ((BaseUnityPlugin)this).Config.Bind<int>("Generation", "AdjacencyImprovePasses", 2, new ConfigDescription("Improvement passes for reducing adjacent same-source rooms.隣接する同一出典部屋を減らす改善パス回数", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 10), Array.Empty<object>()));
				DebugLog = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "DebugLog", false, "Enable debug logging.デバッグログを有効化");
				LogLoadingGraphicNames = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "LogLoadingGraphicNames", false, "Log loading graphic source names for replacement detection.差し替え判定用のローディング画像名ログを出力");
				ExcludedRoomResourcePaths = ((BaseUnityPlugin)this).Config.Bind<string>("Filter", "ExcludedRoomResourcePaths", "", "Exclude specific resource paths. Separate with comma, semicolon, tab, or newline.除外するResourcePathを指定 カンマ セミコロン タブ 改行で区切り");
				LoadCustomLoadingOverrideSprite();
				harmony = new Harmony("REPOJP.AllMapMerge");
				harmony.PatchAll();
				LogSource.LogInfo((object)"AllMapMerge loaded");
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogError((object)("Awake failed\n" + ex));
			}
		}

		internal static bool ShouldApply(Level level)
		{
			if (!Enabled.Value)
			{
				return false;
			}
			if ((Object)(object)RunManager.instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)level == (Object)null)
			{
				return false;
			}
			if (IsAlwaysExcludedLevel(level))
			{
				return false;
			}
			if (!IsGenerationAuthority())
			{
				return false;
			}
			return IsMergedSessionActiveForLevel(level);
		}

		internal static bool ShouldApplyClientVisuals(Level level)
		{
			if (!Enabled.Value)
			{
				return false;
			}
			if ((Object)(object)RunManager.instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)level == (Object)null)
			{
				return false;
			}
			if (IsAlwaysExcludedLevel(level))
			{
				return false;
			}
			if (!PhotonNetwork.InRoom)
			{
				return IsMergedSessionActiveForLevel(level);
			}
			if (IsGenerationAuthority())
			{
				return IsMergedSessionActiveForLevel(level);
			}
			return IsRoomMergedMapActive();
		}

		private static bool IsGenerationAuthority()
		{
			if (!PhotonNetwork.InRoom)
			{
				return true;
			}
			return PhotonNetwork.IsMasterClient;
		}

		private static bool IsRoomMergedMapActive()
		{
			if (!PhotonNetwork.InRoom || PhotonNetwork.CurrentRoom == null)
			{
				return false;
			}
			if (((RoomInfo)PhotonNetwork.CurrentRoom).CustomProperties == null)
			{
				return false;
			}
			if (!((Dictionary<object, object>)(object)((RoomInfo)PhotonNetwork.CurrentRoom).CustomProperties).TryGetValue((object)"REPOJP_AllMapMerge_Active", out object value))
			{
				return false;
			}
			if (!(value is bool result))
			{
				if (value != null && bool.TryParse(value.ToString(), out var result2))
				{
					return result2;
				}
				return false;
			}
			return result;
		}

		private static bool IsMergedSessionActiveForLevel(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return false;
			}
			if (IsAlwaysExcludedLevel(level))
			{
				return false;
			}
			return IsEligibleMergedSourceLevel(level);
		}

		private static void UpdateRoomMergedMapActiveProperty()
		{
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			if (!Enabled.Value || !IsGenerationAuthority() || !PhotonNetwork.InRoom || PhotonNetwork.CurrentRoom == null)
			{
				return;
			}
			Level level = (((Object)(object)RunManager.instance != (Object)null) ? RunManager.instance.levelCurrent : null);
			bool flag = IsMergedSessionActiveForLevel(level);
			bool flag2 = IsRoomMergedMapActive();
			if (flag2 != flag)
			{
				Hashtable val = new Hashtable();
				val[(object)"REPOJP_AllMapMerge_Active"] = flag;
				PhotonNetwork.CurrentRoom.SetCustomProperties(val, (Hashtable)null, (WebFlags)null);
				if (LogSource != null && DebugLog.Value)
				{
					LogSource.LogInfo((object)("Updated room merged-map flag: " + flag + " / level=" + SafeLevelName(level)));
				}
			}
		}

		private static int RunManagerLevelsCount()
		{
			if ((Object)(object)RunManager.instance == (Object)null || RunManager.instance.levels == null)
			{
				return 0;
			}
			return RunManager.instance.levels.Count;
		}

		internal static bool ShouldOverrideRichPresence()
		{
			if (!Enabled.Value)
			{
				return false;
			}
			if ((Object)(object)RunManager.instance == (Object)null || (Object)(object)RunManager.instance.levelCurrent == (Object)null)
			{
				return false;
			}
			if (IsAlwaysExcludedLevel(RunManager.instance.levelCurrent))
			{
				return false;
			}
			if (!PhotonNetwork.InRoom)
			{
				return IsMergedSessionActiveForLevel(RunManager.instance.levelCurrent);
			}
			if (IsGenerationAuthority())
			{
				return IsMergedSessionActiveForLevel(RunManager.instance.levelCurrent);
			}
			return IsRoomMergedMapActive();
		}

		internal static string GetMergedMapPresenceName()
		{
			return "AllMapMerge";
		}

		internal static string GetMergedMapDiscordLargeImageKey()
		{
			return "allmapmerge";
		}

		internal static string GetCustomLoadingOverridePath()
		{
			string text = Path.Combine(Paths.ConfigPath, "AllMapMerge");
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			return Path.Combine(text, "AllMapMerge.png");
		}

		private static void LoadCustomLoadingOverrideSprite()
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)CustomLoadingOverrideSprite != (Object)null)
			{
				try
				{
					if ((Object)(object)CustomLoadingOverrideSprite.texture != (Object)null)
					{
						Object.Destroy((Object)(object)CustomLoadingOverrideSprite.texture);
					}
				}
				catch
				{
				}
				try
				{
					Object.Destroy((Object)(object)CustomLoadingOverrideSprite);
				}
				catch
				{
				}
				CustomLoadingOverrideSprite = null;
			}
			string customLoadingOverridePath = GetCustomLoadingOverridePath();
			if (!File.Exists(customLoadingOverridePath))
			{
				if (LogSource != null)
				{
					LogSource.LogInfo((object)("Custom loading override file not found: " + customLoadingOverridePath));
				}
				return;
			}
			try
			{
				byte[] array = File.ReadAllBytes(customLoadingOverridePath);
				Texture2D val = new Texture2D(2, 2, (TextureFormat)4, false);
				((Object)val).name = "AllMapMerge_LoadingOverride";
				if (!ImageConversion.LoadImage(val, array, false))
				{
					if (LogSource != null)
					{
						LogSource.LogError((object)("Failed to decode image: " + customLoadingOverridePath));
					}
					Object.Destroy((Object)(object)val);
					return;
				}
				((Texture)val).wrapMode = (TextureWrapMode)1;
				((Texture)val).filterMode = (FilterMode)1;
				CustomLoadingOverrideSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
				((Object)CustomLoadingOverrideSprite).name = "AllMapMerge_LoadingOverride_Sprite";
				if (LogSource != null)
				{
					LogSource.LogInfo((object)("Loaded custom loading override: " + customLoadingOverridePath));
				}
			}
			catch (Exception ex)
			{
				if (LogSource != null)
				{
					LogSource.LogError((object)("LoadCustomLoadingOverrideSprite failed\n" + ex));
				}
			}
		}

		private static Level ResolveForcedMuseumBaseLevel()
		{
			if ((Object)(object)RunManager.instance != (Object)null && RunManager.instance.levels != null)
			{
				for (int i = 0; i < RunManager.instance.levels.Count; i++)
				{
					Level val = RunManager.instance.levels[i];
					if (IsForcedMuseumBaseLevel(val))
					{
						return val;
					}
				}
			}
			Level[] array = Resources.FindObjectsOfTypeAll<Level>();
			if (array != null)
			{
				foreach (Level val2 in array)
				{
					if (IsForcedMuseumBaseLevel(val2))
					{
						return val2;
					}
				}
			}
			return null;
		}

		private static bool IsForcedMuseumBaseLevel(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return false;
			}
			if (IsAlwaysExcludedLevel(level))
			{
				return false;
			}
			if (!HasMergeableRoomPools(level))
			{
				return false;
			}
			if (IsMuseumBaseLevelName(level.NarrativeName))
			{
				return true;
			}
			if (IsMuseumBaseLevelName(((Object)level).name))
			{
				return true;
			}
			if ((Object)(object)level.LoadingGraphic01 != (Object)null && IsMuseumBaseTexture(level.LoadingGraphic01))
			{
				return true;
			}
			return false;
		}

		private static bool IsMuseumBaseLevelName(string levelName)
		{
			if (string.IsNullOrWhiteSpace(levelName))
			{
				return false;
			}
			string text = NormalizeTextureName(levelName);
			text = text.Replace("level - ", string.Empty).Trim();
			text = text.Replace("level ", string.Empty).Trim();
			return string.Equals(text, "museum", StringComparison.OrdinalIgnoreCase);
		}

		private static bool IsMuseumBaseTexture(Sprite sprite)
		{
			if ((Object)(object)sprite == (Object)null)
			{
				return false;
			}
			string a = NormalizeTextureName(((Object)sprite).name);
			if (string.Equals(a, "level museum 01", StringComparison.OrdinalIgnoreCase))
			{
				return true;
			}
			if ((Object)(object)sprite.texture != (Object)null)
			{
				string a2 = NormalizeTextureName(((Object)sprite.texture).name);
				if (string.Equals(a2, "level museum 01", StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static List<Level> CollectSourceLevels(Level baseLevel)
		{
			List<Level> result = new List<Level>();
			if ((Object)(object)RunManager.instance == (Object)null)
			{
				return result;
			}
			if (RunManager.instance.levels != null)
			{
				for (int i = 0; i < RunManager.instance.levels.Count; i++)
				{
					AddSourceLevelIfEligible(result, RunManager.instance.levels[i]);
				}
			}
			Level[] array = Resources.FindObjectsOfTypeAll<Level>();
			if (array != null)
			{
				for (int j = 0; j < array.Length; j++)
				{
					AddSourceLevelIfEligible(result, array[j]);
				}
			}
			AddSourceLevelIfEligible(result, baseLevel);
			AddSourceLevelIfEligible(result, RunManager.instance.levelCurrent);
			return result;
		}

		private static void AddSourceLevelIfEligible(List<Level> result, Level level)
		{
			if (result != null && IsEligibleMergedSourceLevel(level) && !result.Contains(level))
			{
				result.Add(level);
			}
		}

		private static bool IsAlwaysExcludedLevel(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return true;
			}
			if ((Object)(object)RunManager.instance == (Object)null)
			{
				return false;
			}
			if ((Object)(object)level == (Object)(object)RunManager.instance.levelMainMenu)
			{
				return true;
			}
			if ((Object)(object)level == (Object)(object)RunManager.instance.levelSplashScreen)
			{
				return true;
			}
			if ((Object)(object)level == (Object)(object)RunManager.instance.levelTutorial)
			{
				return true;
			}
			if ((Object)(object)level == (Object)(object)RunManager.instance.levelLobbyMenu)
			{
				return true;
			}
			if ((Object)(object)level == (Object)(object)RunManager.instance.levelArena)
			{
				return true;
			}
			if ((Object)(object)level == (Object)(object)RunManager.instance.levelShop)
			{
				return true;
			}
			if ((Object)(object)level == (Object)(object)RunManager.instance.levelLobby)
			{
				return true;
			}
			if ((Object)(object)level == (Object)(object)RunManager.instance.levelRecording)
			{
				return true;
			}
			return false;
		}

		private static bool IsEligibleMergedSourceLevel(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return false;
			}
			if ((Object)(object)RunManager.instance == (Object)null)
			{
				return false;
			}
			if (IsAlwaysExcludedLevel(level))
			{
				return false;
			}
			if (!HasMergeableRoomPools(level))
			{
				return false;
			}
			if (DangerousEnableAllMapsMergeIncludingModdedMapsCanBreakMaps != null && DangerousEnableAllMapsMergeIncludingModdedMapsCanBreakMaps.Value)
			{
				return true;
			}
			return IsSafeTargetVanillaLevel(level);
		}

		private static bool IsSafeTargetVanillaLevel(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return false;
			}
			if (IsTargetLoadingTexture(level.LoadingGraphic01))
			{
				return true;
			}
			if (IsSafeTargetVanillaLevelName(level.NarrativeName))
			{
				return true;
			}
			if (IsSafeTargetVanillaLevelName(((Object)level).name))
			{
				return true;
			}
			return false;
		}

		private static bool IsSafeTargetVanillaLevelName(string levelName)
		{
			if (string.IsNullOrWhiteSpace(levelName))
			{
				return false;
			}
			string text = NormalizeTextureName(levelName);
			text = text.Replace("level - ", string.Empty).Trim();
			text = text.Replace("level ", string.Empty).Trim();
			for (int i = 0; i < SafeMergedVanillaLevelNames.Length; i++)
			{
				if (string.Equals(text, SafeMergedVanillaLevelNames[i], StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		private static bool HasMergeableRoomPools(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return false;
			}
			if (HasPrefabRefList(level.StartRooms))
			{
				return true;
			}
			if (HasPrefabRefList(level.ModulesNormal1) || HasPrefabRefList(level.ModulesNormal2) || HasPrefabRefList(level.ModulesNormal3))
			{
				return true;
			}
			if (HasPrefabRefList(level.ModulesPassage1) || HasPrefabRefList(level.ModulesPassage2) || HasPrefabRefList(level.ModulesPassage3))
			{
				return true;
			}
			if (HasPrefabRefList(level.ModulesDeadEnd1) || HasPrefabRefList(level.ModulesDeadEnd2) || HasPrefabRefList(level.ModulesDeadEnd3))
			{
				return true;
			}
			if (HasPrefabRefList(level.ModulesExtraction1) || HasPrefabRefList(level.ModulesExtraction2) || HasPrefabRefList(level.ModulesExtraction3))
			{
				return true;
			}
			return false;
		}

		private static bool HasPrefabRefList(List<PrefabRef> prefabRefs)
		{
			if (prefabRefs == null || prefabRefs.Count <= 0)
			{
				return false;
			}
			for (int i = 0; i < prefabRefs.Count; i++)
			{
				PrefabRef val = prefabRefs[i];
				if (val != null && val.IsValid() && !string.IsNullOrEmpty(val.ResourcePath))
				{
					return true;
				}
			}
			return false;
		}

		private static void PrepareMergedValuablePresets(Level baseLevel)
		{
			if ((Object)(object)baseLevel == (Object)null)
			{
				return;
			}
			CacheOriginalValuablePresets(baseLevel);
			if (!ShouldApply(baseLevel))
			{
				RestoreOriginalValuablePresets(baseLevel);
				return;
			}
			List<LevelValuables> list = BuildMergedValuablePresets(baseLevel);
			if (list.Count <= 0)
			{
				RestoreOriginalValuablePresets(baseLevel);
				return;
			}
			baseLevel.ValuablePresets = list;
			if (DebugLog.Value)
			{
				LogSource.LogInfo((object)("Merged valuable preset count: " + list.Count));
			}
		}

		private static List<LevelValuables> BuildMergedValuablePresets(Level baseLevel)
		{
			List<LevelValuables> list = new List<LevelValuables>();
			List<Level> list2 = CollectValuableSourceLevels(baseLevel);
			for (int i = 0; i < list2.Count; i++)
			{
				List<LevelValuables> originalValuablePresets = GetOriginalValuablePresets(list2[i]);
				for (int j = 0; j < originalValuablePresets.Count; j++)
				{
					LevelValuables val = originalValuablePresets[j];
					if ((Object)(object)val != (Object)null)
					{
						list.Add(val);
					}
				}
			}
			if (DebugLog.Value)
			{
				LogSource.LogInfo((object)("Merged valuable source level count: " + list2.Count));
				for (int k = 0; k < list2.Count; k++)
				{
					Level level = list2[k];
					LogSource.LogInfo((object)("ValuableSourceLevel[" + k + "]: " + SafeLevelName(level) + " / " + SafeLevelPath(level)));
				}
			}
			return list;
		}

		internal static List<Level> CollectValuableSourceLevels(Level baseLevel)
		{
			List<Level> result = new List<Level>();
			if ((Object)(object)RunManager.instance == (Object)null)
			{
				return result;
			}
			if (RunManager.instance.levels != null)
			{
				for (int i = 0; i < RunManager.instance.levels.Count; i++)
				{
					AddValuableSourceLevelIfEligible(result, RunManager.instance.levels[i]);
				}
			}
			Level[] array = Resources.FindObjectsOfTypeAll<Level>();
			if (array != null)
			{
				for (int j = 0; j < array.Length; j++)
				{
					AddValuableSourceLevelIfEligible(result, array[j]);
				}
			}
			AddValuableSourceLevelIfEligible(result, baseLevel);
			AddValuableSourceLevelIfEligible(result, RunManager.instance.levelCurrent);
			return result;
		}

		private static void AddValuableSourceLevelIfEligible(List<Level> result, Level level)
		{
			if (result != null && !((Object)(object)level == (Object)null) && !IsAlwaysExcludedLevel(level) && HasAnyValuablePresets(level) && !result.Contains(level))
			{
				result.Add(level);
			}
		}

		private static bool HasAnyValuablePresets(Level level)
		{
			List<LevelValuables> originalValuablePresets = GetOriginalValuablePresets(level);
			if (originalValuablePresets == null || originalValuablePresets.Count <= 0)
			{
				return false;
			}
			for (int i = 0; i < originalValuablePresets.Count; i++)
			{
				if ((Object)(object)originalValuablePresets[i] != (Object)null)
				{
					return true;
				}
			}
			return false;
		}

		private static void CacheOriginalValuablePresets(Level level)
		{
			if (!((Object)(object)level == (Object)null) && !OriginalValuablePresetsByLevel.ContainsKey(level))
			{
				OriginalValuablePresetsByLevel[level] = CloneValuablePresetList(level.ValuablePresets);
			}
		}

		private static List<LevelValuables> GetOriginalValuablePresets(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return new List<LevelValuables>();
			}
			CacheOriginalValuablePresets(level);
			if (!OriginalValuablePresetsByLevel.TryGetValue(level, out var value) || value == null)
			{
				return new List<LevelValuables>();
			}
			return CloneValuablePresetList(value);
		}

		private static void RestoreOriginalValuablePresets(Level level)
		{
			if (!((Object)(object)level == (Object)null) && OriginalValuablePresetsByLevel.TryGetValue(level, out var value) && value != null)
			{
				level.ValuablePresets = CloneValuablePresetList(value);
			}
		}

		private static List<LevelValuables> CloneValuablePresetList(List<LevelValuables> source)
		{
			List<LevelValuables> list = new List<LevelValuables>();
			if (source == null)
			{
				return list;
			}
			for (int i = 0; i < source.Count; i++)
			{
				LevelValuables val = source[i];
				if ((Object)(object)val != (Object)null)
				{
					list.Add(val);
				}
			}
			return list;
		}

		private static MergedPools BuildMergedPools(Level baseLevel)
		{
			List<Level> list = CollectSourceLevels(baseLevel);
			HashSet<string> excludedPaths = ParseExcludedPaths();
			MergedPools mergedPools = new MergedPools();
			mergedPools.SourceLevels = list;
			for (int i = 0; i < list.Count; i++)
			{
				Level val = list[i];
				AddListToCategoryPool(mergedPools.StartRooms, val, val.StartRooms, excludedPaths, allowDuplicatePaths: false);
			}
			for (int j = 0; j < list.Count; j++)
			{
				Level val2 = list[j];
				if (FullyRandomIgnoreDifficultyTier.Value)
				{
					AddListToCategoryPool(mergedPools.NormalRooms, val2, val2.ModulesNormal1, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.NormalRooms, val2, val2.ModulesNormal2, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.NormalRooms, val2, val2.ModulesNormal3, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.PassageRooms, val2, val2.ModulesPassage1, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.PassageRooms, val2, val2.ModulesPassage2, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.PassageRooms, val2, val2.ModulesPassage3, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.DeadEndRooms, val2, val2.ModulesDeadEnd1, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.DeadEndRooms, val2, val2.ModulesDeadEnd2, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.DeadEndRooms, val2, val2.ModulesDeadEnd3, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.ExtractionRooms, val2, val2.ModulesExtraction1, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.ExtractionRooms, val2, val2.ModulesExtraction2, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.ExtractionRooms, val2, val2.ModulesExtraction3, excludedPaths, allowDuplicatePaths: false);
				}
				else
				{
					AddListToCategoryPool(mergedPools.NormalRooms, val2, val2.ModulesNormal1, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.PassageRooms, val2, val2.ModulesPassage1, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.DeadEndRooms, val2, val2.ModulesDeadEnd1, excludedPaths, allowDuplicatePaths: false);
					AddListToCategoryPool(mergedPools.ExtractionRooms, val2, val2.ModulesExtraction1, excludedPaths, allowDuplicatePaths: false);
				}
			}
			if (DebugLog.Value)
			{
				LogSource.LogInfo((object)("Merged source level count: " + list.Count));
				for (int k = 0; k < list.Count; k++)
				{
					Level level = list[k];
					LogSource.LogInfo((object)("SourceLevel[" + k + "]: " + SafeLevelName(level) + " / " + SafeLevelPath(level)));
				}
				LogSource.LogInfo((object)("MergedStartRooms: " + mergedPools.StartRooms.UniqueCount));
				LogSource.LogInfo((object)("MergedNormalRooms: " + mergedPools.NormalRooms.UniqueCount));
				LogSource.LogInfo((object)("MergedPassageRooms: " + mergedPools.PassageRooms.UniqueCount));
				LogSource.LogInfo((object)("MergedDeadEndRooms: " + mergedPools.DeadEndRooms.UniqueCount));
				LogSource.LogInfo((object)("MergedExtractionRooms: " + mergedPools.ExtractionRooms.UniqueCount));
			}
			return mergedPools;
		}

		private static void AddListToCategoryPool(CategoryPool pool, Level sourceLevel, List<PrefabRef> sourceList, HashSet<string> excludedPaths, bool allowDuplicatePaths)
		{
			if (pool == null || (Object)(object)sourceLevel == (Object)null || sourceList == null)
			{
				return;
			}
			for (int i = 0; i < sourceList.Count; i++)
			{
				PrefabRef val = sourceList[i];
				if (val != null && val.IsValid())
				{
					string resourcePath = val.ResourcePath;
					if (!string.IsNullOrEmpty(resourcePath) && !excludedPaths.Contains(resourcePath) && (allowDuplicatePaths || !pool.ContainsResourcePath(resourcePath)))
					{
						pool.Add(new RoomEntry(val, sourceLevel));
					}
				}
			}
		}

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

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

		private static void OptimizePlannedEntries(Tile[,] levelGrid, RoomEntry[,] plannedEntries, Type[,] plannedTypes, MergedPools pools, int width, int height)
		{
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			if (!PreferDifferentAdjacentSourceLevel.Value)
			{
				return;
			}
			int value = AdjacencyImprovePasses.Value;
			if (value <= 0)
			{
				return;
			}
			for (int i = 0; i < value; i++)
			{
				bool flag = false;
				for (int j = 0; j < width; j++)
				{
					for (int k = 0; k < height; k++)
					{
						Tile val = levelGrid[j, k];
						if (val == null || !val.active)
						{
							continue;
						}
						RoomEntry roomEntry = plannedEntries[j, k];
						if (roomEntry == null)
						{
							continue;
						}
						HashSet<Level> hashSet = CollectAdjacentSourceLevels(plannedEntries, width, height, j, k);
						if (hashSet.Count > 0 && (!((Object)(object)roomEntry.SourceLevel != (Object)null) || hashSet.Contains(roomEntry.SourceLevel)))
						{
							RoomEntry roomEntry2 = GetPoolForType(pools, plannedTypes[j, k])?.ChoosePreferDifferentSource(hashSet, null, roomEntry);
							if (roomEntry2 != null && roomEntry2.PrefabRef != null && roomEntry2 != roomEntry && !((Object)(object)roomEntry2.SourceLevel == (Object)(object)roomEntry.SourceLevel))
							{
								plannedEntries[j, k] = roomEntry2;
								flag = true;
							}
						}
					}
				}
				if (!flag)
				{
					break;
				}
			}
		}

		private static HashSet<Level> CollectAdjacentSourceLevels(RoomEntry[,] plannedEntries, int width, int height, int x, int y)
		{
			HashSet<Level> result = new HashSet<Level>();
			AddPlannedNeighborSourceLevel(plannedEntries, width, height, x, y - 1, result);
			AddPlannedNeighborSourceLevel(plannedEntries, width, height, x - 1, y, result);
			AddPlannedNeighborSourceLevel(plannedEntries, width, height, x + 1, y, result);
			AddPlannedNeighborSourceLevel(plannedEntries, width, height, x, y + 1, result);
			return result;
		}

		private static void AddPlannedNeighborSourceLevel(RoomEntry[,] plannedEntries, int width, int height, int x, int y, HashSet<Level> result)
		{
			if (plannedEntries != null && result != null && x >= 0 && x < width && y >= 0 && y < height)
			{
				RoomEntry roomEntry = plannedEntries[x, y];
				if (roomEntry != null && !((Object)(object)roomEntry.SourceLevel == (Object)null))
				{
					result.Add(roomEntry.SourceLevel);
				}
			}
		}

		private static CategoryPool GetPoolForType(MergedPools pools, Type targetType)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Invalid comparison between Unknown and I4
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Invalid comparison between Unknown and I4
			if (pools == null)
			{
				return null;
			}
			if ((int)targetType == 1)
			{
				return pools.PassageRooms;
			}
			if ((int)targetType == 2)
			{
				return pools.DeadEndRooms;
			}
			if ((int)targetType == 3)
			{
				return pools.ExtractionRooms;
			}
			return pools.NormalRooms;
		}

		private static CategoryUsage GetUsageForType(Type targetType, CategoryUsage normalUsage, CategoryUsage passageUsage, CategoryUsage deadEndUsage, CategoryUsage extractionUsage)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Invalid comparison between Unknown and I4
			if ((int)targetType == 1)
			{
				return passageUsage;
			}
			if ((int)targetType == 2)
			{
				return deadEndUsage;
			}
			if ((int)targetType == 3)
			{
				return extractionUsage;
			}
			return normalUsage;
		}

		private static Type ResolveTargetModuleType(LevelGenerator generator, Tile[,] levelGrid, int x, int y)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			//IL_0014: 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)
			//IL_0036: Invalid comparison between Unknown and I4
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			Tile val = levelGrid[x, y];
			if (val == null)
			{
				return (Type)0;
			}
			if ((int)val.type == 3)
			{
				return (Type)3;
			}
			if ((int)val.type == 2)
			{
				return (Type)2;
			}
			if (PassageAmountRef.Invoke(generator) < generator.Level.PassageMaxAmount)
			{
				bool flag = GridCheckActive(generator, levelGrid, x, y + 1) && (GridCheckActive(generator, levelGrid, x, y - 1) || val.first) && !GridCheckActive(generator, levelGrid, x + 1, y) && !GridCheckActive(generator, levelGrid, x - 1, y);
				bool flag2 = !val.first && GridCheckActive(generator, levelGrid, x + 1, y) && GridCheckActive(generator, levelGrid, x - 1, y) && !GridCheckActive(generator, levelGrid, x, y + 1) && !GridCheckActive(generator, levelGrid, x, y - 1);
				if (flag || flag2)
				{
					PassageAmountRef.Invoke(generator) = PassageAmountRef.Invoke(generator) + 1;
					return (Type)1;
				}
			}
			return (Type)0;
		}

		private static Vector3 ResolveRotation(LevelGenerator generator, Tile[,] levelGrid, int x, int y, Type targetType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Invalid comparison between Unknown and I4
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//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)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			if ((int)targetType == 3 || (int)targetType == 2)
			{
				if (GridCheckActive(generator, levelGrid, x, y - 1))
				{
					return Vector3.zero;
				}
				if (GridCheckActive(generator, levelGrid, x - 1, y))
				{
					return new Vector3(0f, 90f, 0f);
				}
				if (GridCheckActive(generator, levelGrid, x, y + 1))
				{
					return new Vector3(0f, 180f, 0f);
				}
				if (GridCheckActive(generator, levelGrid, x + 1, y))
				{
					return new Vector3(0f, -90f, 0f);
				}
				return Vector3.zero;
			}
			if ((int)targetType == 1)
			{
				bool flag = GridCheckActive(generator, levelGrid, x, y + 1) && (GridCheckActive(generator, levelGrid, x, y - 1) || levelGrid[x, y].first) && !GridCheckActive(generator, levelGrid, x + 1, y) && !GridCheckActive(generator, levelGrid, x - 1, y);
				bool flag2 = !levelGrid[x, y].first && GridCheckActive(generator, levelGrid, x + 1, y) && GridCheckActive(generator, levelGrid, x - 1, y) && !GridCheckActive(generator, levelGrid, x, y + 1) && !GridCheckActive(generator, levelGrid, x, y - 1);
				if (flag)
				{
					if (Random.Range(0, 100) < 50)
					{
						return new Vector3(0f, 180f, 0f);
					}
					return Vector3.zero;
				}
				if (flag2)
				{
					if (Random.Range(0, 100) < 50)
					{
						return new Vector3(0f, -90f, 0f);
					}
					return new Vector3(0f, 90f, 0f);
				}
			}
			Vector3[] array = ModuleRotationsRef.Invoke(generator);
			if (array != null && array.Length != 0)
			{
				return array[Random.Range(0, array.Length)];
			}
			return Vector3.zero;
		}

		private static RoomEntry ChooseRoomEntry(CategoryPool targetPool, MergedPools pools, Type targetType, HashSet<Level> avoidSources, CategoryUsage usage)
		{
			RoomEntry roomEntry = targetPool?.ChoosePreferDifferentSource(avoidSources, usage, null);
			if (roomEntry != null)
			{
				return roomEntry;
			}
			CategoryPool categoryPool = pools?.NormalRooms;
			if (categoryPool != null && categoryPool.UniqueCount > 0)
			{
				return categoryPool.ChoosePreferDifferentSource(avoidSources, usage, null);
			}
			return null;
		}

		private static void SpawnMergedModule(LevelGenerator generator, Tile[,] levelGrid, int x, int y, Vector3 position, Vector3 rotation, Type targetType, RoomEntry entry)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			if (entry == null || entry.PrefabRef == null)
			{
				return;
			}
			GameObject val = null;
			val = ((GameManager.instance.gameMode != 0) ? PhotonNetwork.InstantiateRoomObject(entry.PrefabRef.ResourcePath, position, Quaternion.Euler(rotation), (byte)0, (object[])null) : Object.Instantiate<GameObject>(entry.PrefabRef.Prefab, position, Quaternion.Euler(rotation)));
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			if ((Object)(object)generator.LevelParent != (Object)null)
			{
				val.transform.parent = generator.LevelParent.transform;
			}
			Module component = val.GetComponent<Module>();
			if ((Object)(object)component == (Object)null)
			{
				if (DebugLog.Value)
				{
					LogSource.LogWarning((object)("Spawned merged room has no Module component: " + entry.PrefabRef.ResourcePath));
				}
				return;
			}
			GridXRef.Invoke(component) = x;
			GridYRef.Invoke(component) = y;
			levelGrid[x, y].type = targetType;
			bool first = levelGrid[x, y].first;
			bool flag = GridCheckActive(generator, levelGrid, x, y + 1);
			bool flag2 = GridCheckActive(generator, levelGrid, x, y - 1) || first;
			bool flag3 = GridCheckActive(generator, levelGrid, x + 1, y);
			bool flag4 = GridCheckActive(generator, levelGrid, x - 1, y);
			component.ModuleConnectionSet(flag, flag2, flag3, flag4, first);
			if (DebugLog.Value)
			{
				LogSource.LogInfo((object)("Merged room selected: " + entry.PrefabRef.ResourcePath + " / SourceLevel=" + SafeLevelName(entry.SourceLevel) + " / Type=" + ((object)(Type)(ref targetType)).ToString() + " / Grid=(" + x + "," + y + ")"));
			}
		}

		private static bool GridCheckActive(LevelGenerator generator, Tile[,] levelGrid, int x, int y)
		{
			if ((Object)(object)generator == (Object)null || levelGrid == null)
			{
				return false;
			}
			if (x < 0 || x >= generator.LevelWidth || y < 0 || y >= generator.LevelHeight)
			{
				return false;
			}
			return levelGrid[x, y]?.active ?? false;
		}

		private static CategoryPool BuildCurrentLevelStartPool(Level level)
		{
			CategoryPool categoryPool = new CategoryPool();
			HashSet<string> excludedPaths = ParseExcludedPaths();
			AddListToCategoryPool(categoryPool, level, ((Object)(object)level != (Object)null) ? level.StartRooms : null, excludedPaths, allowDuplicatePaths: false);
			return categoryPool;
		}

		private static MergedPools BuildCurrentLevelPools(Level level)
		{
			MergedPools mergedPools = new MergedPools();
			HashSet<string> excludedPaths = ParseExcludedPaths();
			if ((Object)(object)level == (Object)null)
			{
				return mergedPools;
			}
			mergedPools.SourceLevels.Add(level);
			AddListToCategoryPool(mergedPools.StartRooms, level, level.StartRooms, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.NormalRooms, level, level.ModulesNormal1, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.NormalRooms, level, level.ModulesNormal2, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.NormalRooms, level, level.ModulesNormal3, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.PassageRooms, level, level.ModulesPassage1, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.PassageRooms, level, level.ModulesPassage2, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.PassageRooms, level, level.ModulesPassage3, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.DeadEndRooms, level, level.ModulesDeadEnd1, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.DeadEndRooms, level, level.ModulesDeadEnd2, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.DeadEndRooms, level, level.ModulesDeadEnd3, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.ExtractionRooms, level, level.ModulesExtraction1, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.ExtractionRooms, level, level.ModulesExtraction2, excludedPaths, allowDuplicatePaths: false);
			AddListToCategoryPool(mergedPools.ExtractionRooms, level, level.ModulesExtraction3, excludedPaths, allowDuplicatePaths: false);
			return mergedPools;
		}

		private static HashSet<string> ParseExcludedPaths()
		{
			HashSet<string> hashSet = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
			string value = ExcludedRoomResourcePaths.Value;
			if (string.IsNullOrWhiteSpace(value))
			{
				return hashSet;
			}
			string[] array = value.Split(new char[5] { ',', ';', '\r', '\n', '\t' }, StringSplitOptions.RemoveEmptyEntries);
			foreach (string text in array)
			{
				if (!string.IsNullOrWhiteSpace(text))
				{
					hashSet.Add(text.Trim());
				}
			}
			return hashSet;
		}

		private static string SafeLevelName(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return "null";
			}
			return ((Object)level).name;
		}

		private static string SafeLevelPath(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return "null";
			}
			if (string.IsNullOrEmpty(level.ResourcePath))
			{
				return "";
			}
			return level.ResourcePath;
		}

		internal static bool IsTargetLoadingTexture(Sprite sprite)
		{
			if ((Object)(object)sprite == (Object)null)
			{
				return false;
			}
			string textureName = NormalizeTextureName(((Object)sprite).name);
			if (IsTargetLoadingTextureName(textureName))
			{
				return true;
			}
			if ((Object)(object)sprite.texture != (Object)null)
			{
				string textureName2 = NormalizeTextureName(((Object)sprite.texture).name);
				if (IsTargetLoadingTextureName(textureName2))
				{
					return true;
				}
			}
			return false;
		}

		internal static bool IsTargetLoadingTextureName(string textureName)
		{
			if (string.IsNullOrWhiteSpace(textureName))
			{
				return false;
			}
			string b = NormalizeTextureName(textureName);
			for (int i = 0; i < TargetLoadingTextureNames.Length; i++)
			{
				string a = NormalizeTextureName(TargetLoadingTextureNames[i]);
				if (string.Equals(a, b, StringComparison.OrdinalIgnoreCase))
				{
					return true;
				}
			}
			return false;
		}

		internal static string NormalizeTextureName(string textureName)
		{
			if (string.IsNullOrWhiteSpace(textureName))
			{
				return string.Empty;
			}
			string text = textureName.Trim();
			if (text.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring(0, text.Length - 4);
			}
			return text;
		}

		private static void LogLoadingGraphicCandidateNames(LoadingUI loadingUI, Level level)
		{
			if (LogSource != null && !((Object)(object)level == (Object)null) && LogLoadingGraphicNames != null && LogLoadingGraphicNames.Value)
			{
				LogSource.LogInfo((object)"[AllMapMerge][LoadingGraphicScan] Begin");
				LogLoadingGraphicSlotInfo("LoadingGraphic01", level.LoadingGraphic01, ((Object)(object)loadingUI != (Object)null) ? loadingUI.loadingGraphic01 : null);
				LogLoadingGraphicSlotInfo("LoadingGraphic02", level.LoadingGraphic02, ((Object)(object)loadingUI != (Object)null) ? loadingUI.loadingGraphic02 : null);
				LogLoadingGraphicSlotInfo("LoadingGraphic03", level.LoadingGraphic03, ((Object)(object)loadingUI != (Object)null) ? loadingUI.loadingGraphic03 : null);
				LogSource.LogInfo((object)"[AllMapMerge][LoadingGraphicScan] End");
			}
		}

		private static void LogLoadingGraphicSlotInfo(string slotName, Sprite sourceSprite, Image currentImage)
		{
			string safeSpriteName = GetSafeSpriteName(sourceSprite);
			string safeTextureName = GetSafeTextureName(sourceSprite);
			string text = (((Object)(object)currentImage != (Object)null) ? GetSafeSpriteName(currentImage.sprite) : "null");
			string text2 = (((Object)(object)currentImage != (Object)null) ? GetSafeTextureName(currentImage.sprite) : "null");
			bool flag = IsTargetLoadingTexture(sourceSprite);
			LogSource.LogInfo((object)("[AllMapMerge][LoadingGraphicScan] " + slotName + " | SourceSprite=\"" + safeSpriteName + "\" | SourceTexture=\"" + safeTextureName + "\" | CurrentSprite=\"" + text + "\" | CurrentTexture=\"" + text2 + "\" | MatchedByCurrentRule=" + flag));
		}

		private static string GetSafeSpriteName(Sprite sprite)
		{
			if ((Object)(object)sprite == (Object)null)
			{
				return "null";
			}
			return string.IsNullOrEmpty(((Object)sprite).name) ? "<empty>" : ((Object)sprite).name;
		}

		private static string GetSafeTextureName(Sprite sprite)
		{
			if ((Object)(object)sprite == (Object)null || (Object)(object)sprite.texture == (Object)null)
			{
				return "null";
			}
			return string.IsNullOrEmpty(((Object)sprite.texture).name) ? "<empty>" : ((Object)sprite.texture).name;
		}

		private static void ReplaceMatchedLoadingImage(Image image, Sprite sourceSprite)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)image == (Object)null) && !((Object)(object)sourceSprite == (Object)null) && IsTargetLoadingTexture(sourceSprite))
			{
				image.sprite = CustomLoadingOverrideSprite;
				((Graphic)image).color = Color.white;
				((Behaviour)image).enabled = true;
				if (LogSource != null && DebugLog.Value)
				{
					string text = (((Object)(object)sourceSprite != (Object)null) ? ((Object)sourceSprite).name : "null");
					string text2 = (((Object)(object)sourceSprite != (Object)null && (Object)(object)sourceSprite.texture != (Object)null) ? ((Object)sourceSprite.texture).name : "null");
					LogSource.LogInfo((object)("Replaced loading image source sprite: " + text + " / texture: " + text2));
				}
			}
		}
	}
}