using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
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 HarmonyLib;
using Microsoft.CodeAnalysis;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;

[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 REPOJP.AllMapValuables
{
	[BepInPlugin("REPOJP.AllMapValuables", "AllMapValuables", "4.0.0")]
	public sealed class AllMapValuablesPlugin : BaseUnityPlugin
	{
		public const string PluginGuid = "REPOJP.AllMapValuables";

		public const string PluginName = "AllMapValuables";

		public const string PluginVersion = "4.0.0";

		internal static AllMapValuablesPlugin Instance;

		internal static ManualLogSource ModLogger;

		private Harmony harmony;

		private ConfigEntry<bool> enableMod;

		private ConfigEntry<bool> enableVerboseLog;

		private ConfigEntry<bool> fallbackToVanillaOnError;

		private ConfigEntry<bool> excludeCurrentMapFromExtraPool;

		private readonly Dictionary<string, ConfigEntry<int>> levelWeightConfigs = new Dictionary<string, ConfigEntry<int>>(StringComparer.OrdinalIgnoreCase);

		private void Awake()
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			try
			{
				Instance = this;
				ModLogger = ((BaseUnityPlugin)this).Logger;
				((Component)this).transform.parent = null;
				((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
				Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
				enableMod = ((BaseUnityPlugin)this).Config.Bind<bool>("A General", "EnableMod", true, "Enable or disable this mod. このMODの有効無効");
				enableVerboseLog = ((BaseUnityPlugin)this).Config.Bind<bool>("A General", "EnableVerboseLog", false, "Enable verbose debug logging. 詳細デバッグログ有効");
				fallbackToVanillaOnError = ((BaseUnityPlugin)this).Config.Bind<bool>("A General", "FallbackToVanillaOnError", true, "Fall back to vanilla valuable generation when an error occurs. エラー時バニラ生成へ自動復帰");
				excludeCurrentMapFromExtraPool = ((BaseUnityPlugin)this).Config.Bind<bool>("A General", "ExcludeCurrentMapFromExtraPool", false, "Exclude the current level from the mixed valuable pool. 現在マップ由来の貴重品を混合候補から除外");
				harmony = new Harmony("REPOJP.AllMapValuables");
				harmony.PatchAll();
				WriteInfo("Loaded AllMapValuables v4.0.0");
			}
			catch (Exception ex)
			{
				if (((BaseUnityPlugin)this).Logger != null)
				{
					((BaseUnityPlugin)this).Logger.LogError((object)("Failure: Awake failed.\n" + ex));
				}
			}
		}

		private void OnDestroy()
		{
			try
			{
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
			}
			catch (Exception ex)
			{
				WriteError("Failure: OnDestroy failed.\n" + ex);
			}
		}

		internal bool IsEnabled()
		{
			return enableMod != null && enableMod.Value;
		}

		internal bool IsVerboseLogEnabled()
		{
			return enableVerboseLog != null && enableVerboseLog.Value;
		}

		internal bool IsFallbackToVanillaOnErrorEnabled()
		{
			return fallbackToVanillaOnError != null && fallbackToVanillaOnError.Value;
		}

		internal bool IsExcludeCurrentMapFromExtraPoolEnabled()
		{
			return excludeCurrentMapFromExtraPool != null && excludeCurrentMapFromExtraPool.Value;
		}

		internal void EnsureLevelWeightConfigs()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			if ((Object)(object)RunManager.instance == (Object)null)
			{
				return;
			}
			List<Level> allowedSourceLevels = GetAllowedSourceLevels();
			foreach (Level item in allowedSourceLevels)
			{
				string levelName = GetLevelName(item);
				if (!string.IsNullOrWhiteSpace(levelName) && !levelWeightConfigs.ContainsKey(levelName))
				{
					levelWeightConfigs[levelName] = ((BaseUnityPlugin)this).Config.Bind<int>("B Level Valuable Weights", levelName, 1, new ConfigDescription("Spawn weight for valuables from this level. このマップ由来貴重品の生成重み", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 10), Array.Empty<object>()));
				}
			}
		}

		internal int GetLevelWeight(Level level)
		{
			EnsureLevelWeightConfigs();
			string levelName = GetLevelName(level);
			if (string.IsNullOrWhiteSpace(levelName))
			{
				return 1;
			}
			if (levelWeightConfigs.TryGetValue(levelName, out var value) && value != null)
			{
				return Mathf.Clamp(value.Value, 1, 10);
			}
			return 1;
		}

		internal List<Level> GetAllowedSourceLevels()
		{
			List<Level> list = new List<Level>();
			if ((Object)(object)RunManager.instance == (Object)null)
			{
				return list;
			}
			if (RunManager.instance.levels != null)
			{
				foreach (Level level in RunManager.instance.levels)
				{
					AddAllowedLevel(list, level);
				}
			}
			AddAllowedLevel(list, RunManager.instance.levelCurrent);
			return list;
		}

		internal void AddAllowedLevel(List<Level> levels, Level level)
		{
			if (levels == null || (Object)(object)level == (Object)null || !IsAllowedSourceLevel(level) || (IsExcludeCurrentMapFromExtraPoolEnabled() && (Object)(object)RunManager.instance != (Object)null && (Object)(object)RunManager.instance.levelCurrent == (Object)(object)level))
			{
				return;
			}
			for (int i = 0; i < levels.Count; i++)
			{
				if ((Object)(object)levels[i] == (Object)(object)level)
				{
					return;
				}
			}
			levels.Add(level);
		}

		internal static bool IsAllowedRuntimeLevel()
		{
			try
			{
				if ((Object)(object)RunManager.instance == (Object)null || (Object)(object)RunManager.instance.levelCurrent == (Object)null)
				{
					return false;
				}
				if (!SemiFunc.RunIsLevel())
				{
					return false;
				}
				if ((Object)(object)LevelGenerator.Instance == (Object)null || (Object)(object)LevelGenerator.Instance.Level == (Object)null)
				{
					return false;
				}
				return IsAllowedSourceLevel(LevelGenerator.Instance.Level);
			}
			catch
			{
				return false;
			}
		}

		internal static bool IsAllowedSourceLevel(Level level)
		{
			try
			{
				if ((Object)(object)level == (Object)null)
				{
					return false;
				}
				string levelName = GetLevelName(level);
				if (IsExcludedLevelName(levelName))
				{
					return false;
				}
				if (IsShopOrArenaLevel(level))
				{
					return false;
				}
				if (level.ValuablePresets == null || level.ValuablePresets.Count == 0)
				{
					return false;
				}
				return true;
			}
			catch
			{
				return false;
			}
		}

		internal static string GetLevelName(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return string.Empty;
			}
			return string.IsNullOrWhiteSpace(((Object)level).name) ? string.Empty : ((Object)level).name.Trim();
		}

		internal static bool IsShopOrArenaLevel(Level level)
		{
			if ((Object)(object)level == (Object)null)
			{
				return false;
			}
			if (InvokeSemiFuncLevelBool("IsLevelShop", level) || InvokeSemiFuncLevelBool("IsLevelArena", level))
			{
				return true;
			}
			if (IsLevelInRunManagerField(level, "levelShop") || IsLevelInRunManagerField(level, "levelArena"))
			{
				return true;
			}
			string text = NormalizeLevelName(GetLevelName(level));
			return text.IndexOf("Shop", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Arena", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		private static bool InvokeSemiFuncLevelBool(string methodName, Level level)
		{
			try
			{
				MethodInfo methodInfo = AccessTools.Method(typeof(SemiFunc), methodName, new Type[1] { typeof(Level) }, (Type[])null);
				if (methodInfo == null)
				{
					return false;
				}
				object obj = methodInfo.Invoke(null, new object[1] { level });
				if (obj is bool)
				{
					return (bool)obj;
				}
			}
			catch
			{
				return false;
			}
			return false;
		}

		private static bool IsLevelInRunManagerField(Level level, string fieldName)
		{
			try
			{
				if ((Object)(object)RunManager.instance == (Object)null || (Object)(object)level == (Object)null || string.IsNullOrWhiteSpace(fieldName))
				{
					return false;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(RunManager), fieldName);
				if (fieldInfo == null)
				{
					return false;
				}
				object value = fieldInfo.GetValue(RunManager.instance);
				if (value == null)
				{
					return false;
				}
				Level val = (Level)((value is Level) ? value : null);
				if ((Object)(object)val != (Object)null)
				{
					return IsSameLevel(val, level);
				}
				if (!(value is IEnumerable enumerable))
				{
					return false;
				}
				foreach (object item in enumerable)
				{
					Level val2 = (Level)((item is Level) ? item : null);
					if ((Object)(object)val2 != (Object)null && IsSameLevel(val2, level))
					{
						return true;
					}
				}
			}
			catch
			{
				return false;
			}
			return false;
		}

		private static bool IsSameLevel(Level left, Level right)
		{
			if ((Object)(object)left == (Object)(object)right)
			{
				return true;
			}
			string levelName = GetLevelName(left);
			string levelName2 = GetLevelName(right);
			return !string.IsNullOrWhiteSpace(levelName) && !string.IsNullOrWhiteSpace(levelName2) && string.Equals(levelName, levelName2, StringComparison.OrdinalIgnoreCase);
		}

		private static string NormalizeLevelName(string levelName)
		{
			if (string.IsNullOrWhiteSpace(levelName))
			{
				return string.Empty;
			}
			string text = levelName.Trim();
			if (text.StartsWith("Level - ", StringComparison.OrdinalIgnoreCase))
			{
				text = text.Substring("Level - ".Length).Trim();
			}
			return text;
		}

		internal static bool IsExcludedLevelName(string levelName)
		{
			if (string.IsNullOrWhiteSpace(levelName))
			{
				return true;
			}
			string text = NormalizeLevelName(levelName);
			return string.Equals(text, "Splash Screen", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "Main Menu", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "Lobby Menu", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "Lobby", StringComparison.OrdinalIgnoreCase) || string.Equals(text, "Tutorial", StringComparison.OrdinalIgnoreCase) || text.IndexOf("Shop", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Arena", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("Recording", StringComparison.OrdinalIgnoreCase) >= 0;
		}

		internal static void WriteInfo(string message)
		{
			if (ModLogger != null)
			{
				ModLogger.LogInfo((object)message);
			}
		}

		internal static void WriteWarning(string message)
		{
			if (ModLogger != null)
			{
				ModLogger.LogWarning((object)message);
			}
		}

		internal static void WriteError(string message)
		{
			if (ModLogger != null)
			{
				ModLogger.LogError((object)message);
			}
		}
	}
	[HarmonyPatch(typeof(ValuableDirector), "SetupHost")]
	internal static class ValuableDirectorSetupHostPatch
	{
		private sealed class WeightedPrefabRef
		{
			public PrefabRef PrefabRef;

			public string ResourcePath;

			public int Weight;

			public string SourceLevelName;
		}

		private sealed class WeightedPoolSet
		{
			public readonly List<WeightedPrefabRef> TinyWeighted = new List<WeightedPrefabRef>();

			public readonly List<WeightedPrefabRef> SmallWeighted = new List<WeightedPrefabRef>();

			public readonly List<WeightedPrefabRef> MediumWeighted = new List<WeightedPrefabRef>();

			public readonly List<WeightedPrefabRef> BigWeighted = new List<WeightedPrefabRef>();

			public readonly List<WeightedPrefabRef> WideWeighted = new List<WeightedPrefabRef>();

			public readonly List<WeightedPrefabRef> TallWeighted = new List<WeightedPrefabRef>();

			public readonly List<WeightedPrefabRef> VeryTallWeighted = new List<WeightedPrefabRef>();

			public readonly Dictionary<string, WeightedPrefabRef> TinyUniqueMap = new Dictionary<string, WeightedPrefabRef>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, WeightedPrefabRef> SmallUniqueMap = new Dictionary<string, WeightedPrefabRef>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, WeightedPrefabRef> MediumUniqueMap = new Dictionary<string, WeightedPrefabRef>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, WeightedPrefabRef> BigUniqueMap = new Dictionary<string, WeightedPrefabRef>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, WeightedPrefabRef> WideUniqueMap = new Dictionary<string, WeightedPrefabRef>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, WeightedPrefabRef> TallUniqueMap = new Dictionary<string, WeightedPrefabRef>(StringComparer.OrdinalIgnoreCase);

			public readonly Dictionary<string, WeightedPrefabRef> VeryTallUniqueMap = new Dictionary<string, WeightedPrefabRef>(StringComparer.OrdinalIgnoreCase);

			public List<PrefabRef> TinyUnique = new List<PrefabRef>();

			public List<PrefabRef> SmallUnique = new List<PrefabRef>();

			public List<PrefabRef> MediumUnique = new List<PrefabRef>();

			public List<PrefabRef> BigUnique = new List<PrefabRef>();

			public List<PrefabRef> WideUnique = new List<PrefabRef>();

			public List<PrefabRef> TallUnique = new List<PrefabRef>();

			public List<PrefabRef> VeryTallUnique = new List<PrefabRef>();

			public bool IsCompletelyEmpty()
			{
				return TinyWeighted.Count == 0 && SmallWeighted.Count == 0 && MediumWeighted.Count == 0 && BigWeighted.Count == 0 && WideWeighted.Count == 0 && TallWeighted.Count == 0 && VeryTallWeighted.Count == 0;
			}
		}

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

			private object <>2__current;

			public ValuableDirector director;

			private bool <setupSuccess>5__1;

			private WeightedPoolSet <poolSet>5__2;

			private List<ValuableVolume> <allVolumes>5__3;

			private List<ValuableVolume> <tinyVolumes>5__4;

			private List<ValuableVolume> <smallVolumes>5__5;

			private List<ValuableVolume> <mediumVolumes>5__6;

			private List<ValuableVolume> <bigVolumes>5__7;

			private List<ValuableVolume> <wideVolumes>5__8;

			private List<ValuableVolume> <tallVolumes>5__9;

			private List<ValuableVolume> <veryTallVolumes>5__10;

			private int <totalMaxAmount>5__11;

			private int[] <maxAmounts>5__12;

			private string[] <paths>5__13;

			private int[] <chances>5__14;

			private List<ValuableVolume>[] <volumeLists>5__15;

			private List<WeightedPrefabRef>[] <weightedPools>5__16;

			private int[] <volumeIndex>5__17;

			private int <index>5__18;

			private int <selectedCategoryIndex>5__19;

			private ValuableVolume <targetVolume>5__20;

			private WeightedPrefabRef <selectedValuable>5__21;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<poolSet>5__2 = null;
				<allVolumes>5__3 = null;
				<tinyVolumes>5__4 = null;
				<smallVolumes>5__5 = null;
				<mediumVolumes>5__6 = null;
				<bigVolumes>5__7 = null;
				<wideVolumes>5__8 = null;
				<tallVolumes>5__9 = null;
				<veryTallVolumes>5__10 = null;
				<maxAmounts>5__12 = null;
				<paths>5__13 = null;
				<chances>5__14 = null;
				<volumeLists>5__15 = null;
				<weightedPools>5__16 = null;
				<volumeIndex>5__17 = null;
				<targetVolume>5__20 = null;
				<selectedValuable>5__21 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0860: Unknown result type (might be due to invalid IL or missing references)
				//IL_086a: Expected O, but got Unknown
				//IL_08c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_08d2: Expected O, but got Unknown
				//IL_0924: Unknown result type (might be due to invalid IL or missing references)
				//IL_092e: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<setupSuccess>5__1 = false;
					PrepareDirectorState(director);
					CalculateMaxAmounts(director);
					<poolSet>5__2 = BuildWeightedPoolSet();
					if (<poolSet>5__2.IsCompletelyEmpty())
					{
						AllMapValuablesPlugin.WriteWarning("Failure: Valuable pool is empty. No valuables will be spawned by AllMapValuables.");
						SetAllMaxAmounts(director, 0);
					}
					SetFieldValue(TinyValuablesField, director, <poolSet>5__2.TinyUnique);
					SetFieldValue(SmallValuablesField, director, <poolSet>5__2.SmallUnique);
					SetFieldValue(MediumValuablesField, director, <poolSet>5__2.MediumUnique);
					SetFieldValue(BigValuablesField, director, <poolSet>5__2.BigUnique);
					SetFieldValue(WideValuablesField, director, <poolSet>5__2.WideUnique);
					SetFieldValue(TallValuablesField, director, <poolSet>5__2.TallUnique);
					SetFieldValue(VeryTallValuablesField, director, <poolSet>5__2.VeryTallUnique);
					<allVolumes>5__3 = GetValuableVolumes();
					<tinyVolumes>5__4 = GetVolumesByType(<allVolumes>5__3, (Type)0);
					<smallVolumes>5__5 = GetVolumesByType(<allVolumes>5__3, (Type)1);
					<mediumVolumes>5__6 = GetVolumesByType(<allVolumes>5__3, (Type)2);
					<bigVolumes>5__7 = GetVolumesByType(<allVolumes>5__3, (Type)3);
					<wideVolumes>5__8 = GetVolumesByType(<allVolumes>5__3, (Type)4);
					<tallVolumes>5__9 = GetVolumesByType(<allVolumes>5__3, (Type)5);
					<veryTallVolumes>5__10 = GetVolumesByType(<allVolumes>5__3, (Type)6);
					ShuffleList(<tinyVolumes>5__4);
					ShuffleList(<smallVolumes>5__5);
					ShuffleList(<mediumVolumes>5__6);
					ShuffleList(<bigVolumes>5__7);
					ShuffleList(<wideVolumes>5__8);
					ShuffleList(<tallVolumes>5__9);
					ShuffleList(<veryTallVolumes>5__10);
					SetFieldValue(TinyVolumesField, director, <tinyVolumes>5__4);
					SetFieldValue(SmallVolumesField, director, <smallVolumes>5__5);
					SetFieldValue(MediumVolumesField, director, <mediumVolumes>5__6);
					SetFieldValue(BigVolumesField, director, <bigVolumes>5__7);
					SetFieldValue(WideVolumesField, director, <wideVolumes>5__8);
					SetFieldValue(TallVolumesField, director, <tallVolumes>5__9);
					SetFieldValue(VeryTallVolumesField, director, <veryTallVolumes>5__10);
					ApplyValuableDebugMode(director, <allVolumes>5__3, <tinyVolumes>5__4, <smallVolumes>5__5, <mediumVolumes>5__6, <bigVolumes>5__7, <wideVolumes>5__8, <tallVolumes>5__9, <veryTallVolumes>5__10, <poolSet>5__2);
					<totalMaxAmount>5__11 = Mathf.Max(0, GetFieldValue<int>(TotalMaxAmountField, director));
					<maxAmounts>5__12 = new int[7]
					{
						Mathf.Max(0, GetFieldValue<int>(TinyMaxAmountField, director)),
						Mathf.Max(0, GetFieldValue<int>(SmallMaxAmountField, director)),
						Mathf.Max(0, GetFieldValue<int>(MediumMaxAmountField, director)),
						Mathf.Max(0, GetFieldValue<int>(BigMaxAmountField, director)),
						Mathf.Max(0, GetFieldValue<int>(WideMaxAmountField, director)),
						Mathf.Max(0, GetFieldValue<int>(TallMaxAmountField, director)),
						Mathf.Max(0, GetFieldValue<int>(VeryTallMaxAmountField, director))
					};
					<paths>5__13 = new string[7]
					{
						GetFieldValue<string>(TinyPathField, director),
						GetFieldValue<string>(SmallPathField, director),
						GetFieldValue<string>(MediumPathField, director),
						GetFieldValue<string>(BigPathField, director),
						GetFieldValue<string>(WidePathField, director),
						GetFieldValue<string>(TallPathField, director),
						GetFieldValue<string>(VeryTallPathField, director)
					};
					<chances>5__14 = new int[7]
					{
						Mathf.Max(1, director.tinyChance),
						Mathf.Max(1, director.smallChance),
						Mathf.Max(1, director.mediumChance),
						Mathf.Max(1, director.bigChance),
						Mathf.Max(1, director.wideChance),
						Mathf.Max(1, director.tallChance),
						Mathf.Max(1, director.veryTallChance)
					};
					<volumeLists>5__15 = new List<ValuableVolume>[7] { <tinyVolumes>5__4, <smallVolumes>5__5, <mediumVolumes>5__6, <bigVolumes>5__7, <wideVolumes>5__8, <tallVolumes>5__9, <veryTallVolumes>5__10 };
					<weightedPools>5__16 = new List<WeightedPrefabRef>[7] { <poolSet>5__2.TinyWeighted, <poolSet>5__2.SmallWeighted, <poolSet>5__2.MediumWeighted, <poolSet>5__2.BigWeighted, <poolSet>5__2.WideWeighted, <poolSet>5__2.TallWeighted, <poolSet>5__2.VeryTallWeighted };
					<volumeIndex>5__17 = new int[7];
					if ((Object)(object)AllMapValuablesPlugin.Instance != (Object)null && AllMapValuablesPlugin.Instance.IsVerboseLogEnabled())
					{
						AllMapValuablesPlugin.WriteInfo($"Pool Summary | Tiny:{<poolSet>5__2.TinyWeighted.Count} Small:{<poolSet>5__2.SmallWeighted.Count} Medium:{<poolSet>5__2.MediumWeighted.Count} Big:{<poolSet>5__2.BigWeighted.Count} Wide:{<poolSet>5__2.WideWeighted.Count} Tall:{<poolSet>5__2.TallWeighted.Count} VeryTall:{<poolSet>5__2.VeryTallWeighted.Count}");
					}
					<index>5__18 = 0;
					goto IL_07f6;
				case 1:
					<>1__state = -1;
					<targetVolume>5__20 = null;
					<selectedValuable>5__21 = null;
					goto IL_07e4;
				case 2:
					<>1__state = -1;
					goto IL_087b;
				case 3:
					<>1__state = -1;
					goto IL_08e3;
				case 4:
					{
						<>1__state = -1;
						break;
					}
					IL_08e3:
					if (IsMultiplayerRoomActive() && GetFieldValue<int>(CosmeticWorldObjectSpawnPlayerReadyField, director) < PhotonNetwork.CurrentRoom.PlayerCount)
					{
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 3;
						return true;
					}
					director.VolumesAndSwitchSetup();
					break;
					IL_07f6:
					if (<index>5__18 < <totalMaxAmount>5__11)
					{
						<selectedCategoryIndex>5__19 = SelectCategoryIndex(<maxAmounts>5__12, <volumeIndex>5__17, <volumeLists>5__15, <weightedPools>5__16, <chances>5__14);
						if (<selectedCategoryIndex>5__19 != -1)
						{
							<targetVolume>5__20 = <volumeLists>5__15[<selectedCategoryIndex>5__19][<volumeIndex>5__17[<selectedCategoryIndex>5__19]];
							<selectedValuable>5__21 = PickWeightedPrefab(<weightedPools>5__16[<selectedCategoryIndex>5__19]);
							if (<selectedValuable>5__21 == null || <selectedValuable>5__21.PrefabRef == null)
							{
								<volumeIndex>5__17[<selectedCategoryIndex>5__19]++;
								goto IL_07e4;
							}
							InvokeSpawnValuable(director, <selectedValuable>5__21.PrefabRef, <targetVolume>5__20, <paths>5__13[<selectedCategoryIndex>5__19]);
							<volumeIndex>5__17[<selectedCategoryIndex>5__19]++;
							<>2__current = null;
							<>1__state = 1;
							return true;
						}
					}
					WriteSpawnShortageLog(director, <maxAmounts>5__12, <volumeIndex>5__17);
					RpcTargetAmount(director, "ValuablesTargetSetRPC", GetFieldValue<int>(ValuableTargetAmountField, director));
					IncrementIntField(ValuableSpawnPlayerReadyField, director);
					goto IL_087b;
					IL_087b:
					if (IsMultiplayerRoomActive() && GetFieldValue<int>(ValuableSpawnPlayerReadyField, director) < PhotonNetwork.CurrentRoom.PlayerCount)
					{
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 2;
						return true;
					}
					RunCosmeticWorldObjectSetup(director, <volumeIndex>5__17, <volumeLists>5__15);
					goto IL_08e3;
					IL_07e4:
					<index>5__18++;
					goto IL_07f6;
				}
				if (IsMultiplayerRoomActive() && GetFieldValue<int>(SwitchSetupPlayerReadyField, director) < PhotonNetwork.CurrentRoom.PlayerCount)
				{
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 4;
					return true;
				}
				SetFieldValue(SetupCompleteField, director, true);
				<setupSuccess>5__1 = true;
				if ((Object)(object)AllMapValuablesPlugin.Instance != (Object)null && AllMapValuablesPlugin.Instance.IsVerboseLogEnabled())
				{
					AllMapValuablesPlugin.WriteInfo("AllMapValuables setup completed.");
				}
				if (!<setupSuccess>5__1)
				{
					return 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();
			}
		}

		private static readonly MethodInfo SpawnValuableMethod = AccessTools.Method(typeof(ValuableDirector), "SpawnValuable", (Type[])null, (Type[])null);

		private static readonly MethodInfo SpawnCosmeticWorldObjectMethod = AccessTools.Method(typeof(ValuableDirector), "SpawnCosmeticWorldObject", (Type[])null, (Type[])null);

		private static readonly MethodInfo CosmeticWorldObjectLevelLoopsGetMethod = AccessTools.Method(typeof(ValuableDirector), "CosmeticWorldObjectLevelLoopsGet", (Type[])null, (Type[])null);

		private static readonly MethodInfo CosmeticWorldObjectLevelLoopsClampedGetMethod = AccessTools.Method(typeof(ValuableDirector), "CosmeticWorldObjectLevelLoopsClampedGet", (Type[])null, (Type[])null);

		private static readonly FieldInfo ValuableDebugField = AccessTools.Field(typeof(ValuableDirector), "valuableDebug");

		private static readonly FieldInfo SetupCompleteField = AccessTools.Field(typeof(ValuableDirector), "setupComplete");

		private static readonly FieldInfo ValuableSpawnPlayerReadyListField = AccessTools.Field(typeof(ValuableDirector), "valuableSpawnPlayerReadyList");

		private static readonly FieldInfo ValuableSpawnPlayerReadyField = AccessTools.Field(typeof(ValuableDirector), "valuableSpawnPlayerReady");

		private static readonly FieldInfo ValuableTargetAmountField = AccessTools.Field(typeof(ValuableDirector), "valuableTargetAmount");

		private static readonly FieldInfo SwitchSetupPlayerReadyListField = AccessTools.Field(typeof(ValuableDirector), "switchSetupPlayerReadyList");

		private static readonly FieldInfo SwitchSetupPlayerReadyField = AccessTools.Field(typeof(ValuableDirector), "switchSetupPlayerReady");

		private static readonly FieldInfo TotalMaxValueField = AccessTools.Field(typeof(ValuableDirector), "totalMaxValue");

		private static readonly FieldInfo TotalCurrentValueField = AccessTools.Field(typeof(ValuableDirector), "totalCurrentValue");

		private static readonly FieldInfo TotalMaxAmountField = AccessTools.Field(typeof(ValuableDirector), "totalMaxAmount");

		private static readonly FieldInfo TinyMaxAmountField = AccessTools.Field(typeof(ValuableDirector), "tinyMaxAmount");

		private static readonly FieldInfo SmallMaxAmountField = AccessTools.Field(typeof(ValuableDirector), "smallMaxAmount");

		private static readonly FieldInfo MediumMaxAmountField = AccessTools.Field(typeof(ValuableDirector), "mediumMaxAmount");

		private static readonly FieldInfo BigMaxAmountField = AccessTools.Field(typeof(ValuableDirector), "bigMaxAmount");

		private static readonly FieldInfo WideMaxAmountField = AccessTools.Field(typeof(ValuableDirector), "wideMaxAmount");

		private static readonly FieldInfo TallMaxAmountField = AccessTools.Field(typeof(ValuableDirector), "tallMaxAmount");

		private static readonly FieldInfo VeryTallMaxAmountField = AccessTools.Field(typeof(ValuableDirector), "veryTallMaxAmount");

		private static readonly FieldInfo TinyValuablesField = AccessTools.Field(typeof(ValuableDirector), "tinyValuables");

		private static readonly FieldInfo SmallValuablesField = AccessTools.Field(typeof(ValuableDirector), "smallValuables");

		private static readonly FieldInfo MediumValuablesField = AccessTools.Field(typeof(ValuableDirector), "mediumValuables");

		private static readonly FieldInfo BigValuablesField = AccessTools.Field(typeof(ValuableDirector), "bigValuables");

		private static readonly FieldInfo WideValuablesField = AccessTools.Field(typeof(ValuableDirector), "wideValuables");

		private static readonly FieldInfo TallValuablesField = AccessTools.Field(typeof(ValuableDirector), "tallValuables");

		private static readonly FieldInfo VeryTallValuablesField = AccessTools.Field(typeof(ValuableDirector), "veryTallValuables");

		private static readonly FieldInfo TinyVolumesField = AccessTools.Field(typeof(ValuableDirector), "tinyVolumes");

		private static readonly FieldInfo SmallVolumesField = AccessTools.Field(typeof(ValuableDirector), "smallVolumes");

		private static readonly FieldInfo MediumVolumesField = AccessTools.Field(typeof(ValuableDirector), "mediumVolumes");

		private static readonly FieldInfo BigVolumesField = AccessTools.Field(typeof(ValuableDirector), "bigVolumes");

		private static readonly FieldInfo WideVolumesField = AccessTools.Field(typeof(ValuableDirector), "wideVolumes");

		private static readonly FieldInfo TallVolumesField = AccessTools.Field(typeof(ValuableDirector), "tallVolumes");

		private static readonly FieldInfo VeryTallVolumesField = AccessTools.Field(typeof(ValuableDirector), "veryTallVolumes");

		private static readonly FieldInfo TinyPathField = AccessTools.Field(typeof(ValuableDirector), "tinyPath");

		private static readonly FieldInfo SmallPathField = AccessTools.Field(typeof(ValuableDirector), "smallPath");

		private static readonly FieldInfo MediumPathField = AccessTools.Field(typeof(ValuableDirector), "mediumPath");

		private static readonly FieldInfo BigPathField = AccessTools.Field(typeof(ValuableDirector), "bigPath");

		private static readonly FieldInfo WidePathField = AccessTools.Field(typeof(ValuableDirector), "widePath");

		private static readonly FieldInfo TallPathField = AccessTools.Field(typeof(ValuableDirector), "tallPath");

		private static readonly FieldInfo VeryTallPathField = AccessTools.Field(typeof(ValuableDirector), "veryTallPath");

		private static readonly FieldInfo CosmeticWorldObjectDebugField = AccessTools.Field(typeof(ValuableDirector), "cosmeticWorldObjectDebug");

		private static readonly FieldInfo CosmeticWorldObjectsSpawnCurveField = AccessTools.Field(typeof(ValuableDirector), "cosmeticWorldObjectsSpawnCurve");

		private static readonly FieldInfo CosmeticWorldObjectsLevelLoopField = AccessTools.Field(typeof(ValuableDirector), "cosmeticWorldObjectsLevelLoop");

		private static readonly FieldInfo CosmeticWorldObjectsLevelLoopsMaxField = AccessTools.Field(typeof(ValuableDirector), "cosmeticWorldObjectsLevelLoopsMax");

		private static readonly FieldInfo CosmeticWorldObjectSetupsField = AccessTools.Field(typeof(ValuableDirector), "cosmeticWorldObjectSetups");

		private static readonly FieldInfo CosmeticWorldObjectSpawnPlayerReadyListField = AccessTools.Field(typeof(ValuableDirector), "cosmeticWorldObjectSpawnPlayerReadyList");

		private static readonly FieldInfo CosmeticWorldObjectSpawnPlayerReadyField = AccessTools.Field(typeof(ValuableDirector), "cosmeticWorldObjectSpawnPlayerReady");

		private static readonly FieldInfo CosmeticWorldObjectTargetAmountField = AccessTools.Field(typeof(ValuableDirector), "cosmeticWorldObjectTargetAmount");

		private static readonly FieldInfo RunManagerCosmeticWorldObjectBadLuckCountField = AccessTools.Field(typeof(RunManager), "cosmeticWorldObjectBadLuckCount");

		private static bool Prefix(ValuableDirector __instance, ref IEnumerator __result)
		{
			if ((Object)(object)AllMapValuablesPlugin.Instance == (Object)null || !AllMapValuablesPlugin.Instance.IsEnabled())
			{
				return true;
			}
			if ((Object)(object)GameManager.instance != (Object)null && GameManager.instance.gameMode == 1 && !PhotonNetwork.IsMasterClient)
			{
				return true;
			}
			if (!AllMapValuablesPlugin.IsAllowedRuntimeLevel())
			{
				return true;
			}
			if (!HasRequiredMembers())
			{
				AllMapValuablesPlugin.WriteWarning("Failure: Required ValuableDirector members were not found. Falling back to vanilla generation.");
				return true;
			}
			try
			{
				AllMapValuablesPlugin.Instance.EnsureLevelWeightConfigs();
				__result = CustomSetupHost(__instance);
				return false;
			}
			catch (Exception ex)
			{
				AllMapValuablesPlugin.WriteError("Failure: Failed to start custom valuable generation.\n" + ex);
				return AllMapValuablesPlugin.Instance.IsFallbackToVanillaOnErrorEnabled();
			}
		}

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

		private static bool HasRequiredMembers()
		{
			return SpawnValuableMethod != null && ValuableTargetAmountField != null && ValuableSpawnPlayerReadyField != null && SwitchSetupPlayerReadyField != null && TotalMaxAmountField != null && TinyValuablesField != null && SmallValuablesField != null && MediumValuablesField != null && BigValuablesField != null && WideValuablesField != null && TallValuablesField != null && VeryTallValuablesField != null;
		}

		private static void PrepareDirectorState(ValuableDirector director)
		{
			SetFieldValue(SetupCompleteField, director, false);
			SetFieldValue(ValuableTargetAmountField, director, 0);
			SetFieldValue(TotalCurrentValueField, director, 0f);
			SetFieldValue(ValuableSpawnPlayerReadyField, director, 0);
			SetFieldValue(SwitchSetupPlayerReadyField, director, 0);
			SetFieldValue(ValuableSpawnPlayerReadyListField, director, new List<Player>());
			SetFieldValue(SwitchSetupPlayerReadyListField, director, new List<Player>());
			SetFieldValue(CosmeticWorldObjectTargetAmountField, director, 0);
			SetFieldValue(CosmeticWorldObjectSpawnPlayerReadyField, director, 0);
			SetFieldValue(CosmeticWorldObjectSpawnPlayerReadyListField, director, new List<Player>());
		}

		private static void CalculateMaxAmounts(ValuableDirector director)
		{
			if (SemiFunc.RunGetDifficultyMultiplier2() > 0f && !SemiFunc.RunIsArena())
			{
				float num = SemiFunc.RunGetDifficultyMultiplier2();
				SetFieldValue(TotalMaxValueField, director, (float)Mathf.RoundToInt(director.totalMaxValueCurve2.Evaluate(num)));
				SetFieldValue(TinyMaxAmountField, director, Mathf.RoundToInt(director.tinyMaxAmountCurve2.Evaluate(num)));
				SetFieldValue(SmallMaxAmountField, director, Mathf.RoundToInt(director.smallMaxAmountCurve2.Evaluate(num)));
				SetFieldValue(MediumMaxAmountField, director, Mathf.RoundToInt(director.mediumMaxAmountCurve2.Evaluate(num)));
				SetFieldValue(BigMaxAmountField, director, Mathf.RoundToInt(director.bigMaxAmountCurve2.Evaluate(num)));
				SetFieldValue(WideMaxAmountField, director, Mathf.RoundToInt(director.wideMaxAmountCurve2.Evaluate(num)));
				SetFieldValue(TallMaxAmountField, director, Mathf.RoundToInt(director.tallMaxAmountCurve2.Evaluate(num)));
				SetFieldValue(VeryTallMaxAmountField, director, Mathf.RoundToInt(director.veryTallMaxAmountCurve2.Evaluate(num)));
			}
			else
			{
				float num2 = SemiFunc.RunGetDifficultyMultiplier1();
				SetFieldValue(TotalMaxValueField, director, (float)Mathf.RoundToInt(director.totalMaxValueCurve1.Evaluate(num2)));
				SetFieldValue(TinyMaxAmountField, director, Mathf.RoundToInt(director.tinyMaxAmountCurve1.Evaluate(num2)));
				SetFieldValue(SmallMaxAmountField, director, Mathf.RoundToInt(director.smallMaxAmountCurve1.Evaluate(num2)));
				SetFieldValue(MediumMaxAmountField, director, Mathf.RoundToInt(director.mediumMaxAmountCurve1.Evaluate(num2)));
				SetFieldValue(BigMaxAmountField, director, Mathf.RoundToInt(director.bigMaxAmountCurve1.Evaluate(num2)));
				SetFieldValue(WideMaxAmountField, director, Mathf.RoundToInt(director.wideMaxAmountCurve1.Evaluate(num2)));
				SetFieldValue(TallMaxAmountField, director, Mathf.RoundToInt(director.tallMaxAmountCurve1.Evaluate(num2)));
				SetFieldValue(VeryTallMaxAmountField, director, Mathf.RoundToInt(director.veryTallMaxAmountCurve1.Evaluate(num2)));
			}
		}

		private static void SetAllMaxAmounts(ValuableDirector director, int value)
		{
			SetFieldValue(TotalMaxAmountField, director, value);
			SetFieldValue(TinyMaxAmountField, director, value);
			SetFieldValue(SmallMaxAmountField, director, value);
			SetFieldValue(MediumMaxAmountField, director, value);
			SetFieldValue(BigMaxAmountField, director, value);
			SetFieldValue(WideMaxAmountField, director, value);
			SetFieldValue(TallMaxAmountField, director, value);
			SetFieldValue(VeryTallMaxAmountField, director, value);
		}

		private static WeightedPoolSet BuildWeightedPoolSet()
		{
			WeightedPoolSet weightedPoolSet = new WeightedPoolSet();
			if ((Object)(object)AllMapValuablesPlugin.Instance == (Object)null)
			{
				return weightedPoolSet;
			}
			List<Level> allowedSourceLevels = AllMapValuablesPlugin.Instance.GetAllowedSourceLevels();
			foreach (Level item in allowedSourceLevels)
			{
				if ((Object)(object)item == (Object)null || item.ValuablePresets == null || item.ValuablePresets.Count == 0)
				{
					continue;
				}
				string levelName = AllMapValuablesPlugin.GetLevelName(item);
				int levelWeight = AllMapValuablesPlugin.Instance.GetLevelWeight(item);
				foreach (LevelValuables valuablePreset in item.ValuablePresets)
				{
					if (!((Object)(object)valuablePreset == (Object)null))
					{
						AddWeightedPrefabs(weightedPoolSet.TinyWeighted, weightedPoolSet.TinyUniqueMap, valuablePreset.tiny, levelWeight, levelName);
						AddWeightedPrefabs(weightedPoolSet.SmallWeighted, weightedPoolSet.SmallUniqueMap, valuablePreset.small, levelWeight, levelName);
						AddWeightedPrefabs(weightedPoolSet.MediumWeighted, weightedPoolSet.MediumUniqueMap, valuablePreset.medium, levelWeight, levelName);
						AddWeightedPrefabs(weightedPoolSet.BigWeighted, weightedPoolSet.BigUniqueMap, valuablePreset.big, levelWeight, levelName);
						AddWeightedPrefabs(weightedPoolSet.WideWeighted, weightedPoolSet.WideUniqueMap, valuablePreset.wide, levelWeight, levelName);
						AddWeightedPrefabs(weightedPoolSet.TallWeighted, weightedPoolSet.TallUniqueMap, valuablePreset.tall, levelWeight, levelName);
						AddWeightedPrefabs(weightedPoolSet.VeryTallWeighted, weightedPoolSet.VeryTallUniqueMap, valuablePreset.veryTall, levelWeight, levelName);
					}
				}
			}
			weightedPoolSet.TinyUnique = GetUniquePrefabList(weightedPoolSet.TinyUniqueMap);
			weightedPoolSet.SmallUnique = GetUniquePrefabList(weightedPoolSet.SmallUniqueMap);
			weightedPoolSet.MediumUnique = GetUniquePrefabList(weightedPoolSet.MediumUniqueMap);
			weightedPoolSet.BigUnique = GetUniquePrefabList(weightedPoolSet.BigUniqueMap);
			weightedPoolSet.WideUnique = GetUniquePrefabList(weightedPoolSet.WideUniqueMap);
			weightedPoolSet.TallUnique = GetUniquePrefabList(weightedPoolSet.TallUniqueMap);
			weightedPoolSet.VeryTallUnique = GetUniquePrefabList(weightedPoolSet.VeryTallUniqueMap);
			return weightedPoolSet;
		}

		private static void AddWeightedPrefabs(List<WeightedPrefabRef> weightedList, Dictionary<string, WeightedPrefabRef> uniqueMap, List<PrefabRef> source, int levelWeight, string levelName)
		{
			if (weightedList == null || uniqueMap == null || source == null || source.Count == 0)
			{
				return;
			}
			foreach (PrefabRef item in source)
			{
				if (item == null || !item.IsValid())
				{
					continue;
				}
				string resourcePath = item.ResourcePath;
				if (!string.IsNullOrWhiteSpace(resourcePath))
				{
					if (uniqueMap.TryGetValue(resourcePath, out var value))
					{
						value.Weight += Mathf.Clamp(levelWeight, 1, 10);
						continue;
					}
					value = new WeightedPrefabRef();
					value.PrefabRef = item;
					value.ResourcePath = resourcePath;
					value.Weight = Mathf.Clamp(levelWeight, 1, 10);
					value.SourceLevelName = levelName;
					uniqueMap.Add(resourcePath, value);
					weightedList.Add(value);
				}
			}
		}

		private static List<PrefabRef> GetUniquePrefabList(Dictionary<string, WeightedPrefabRef> uniqueMap)
		{
			List<PrefabRef> list = new List<PrefabRef>();
			if (uniqueMap == null)
			{
				return list;
			}
			foreach (KeyValuePair<string, WeightedPrefabRef> item in uniqueMap)
			{
				if (item.Value != null && item.Value.PrefabRef != null)
				{
					list.Add(item.Value.PrefabRef);
				}
			}
			return list;
		}

		private static List<ValuableVolume> GetValuableVolumes()
		{
			ValuableVolume[] array = Object.FindObjectsOfType<ValuableVolume>(false);
			if (array == null || array.Length == 0)
			{
				return new List<ValuableVolume>();
			}
			return new List<ValuableVolume>(array);
		}

		private static List<ValuableVolume> GetVolumesByType(List<ValuableVolume> allVolumes, Type volumeType)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			List<ValuableVolume> list = new List<ValuableVolume>();
			if (allVolumes == null)
			{
				return list;
			}
			foreach (ValuableVolume allVolume in allVolumes)
			{
				if ((Object)(object)allVolume != (Object)null && allVolume.VolumeType == volumeType)
				{
					list.Add(allVolume);
				}
			}
			return list;
		}

		private static void ShuffleList<T>(List<T> list)
		{
			if (list != null && list.Count > 1)
			{
				for (int num = list.Count - 1; num > 0; num--)
				{
					int index = Random.Range(0, num + 1);
					T value = list[num];
					list[num] = list[index];
					list[index] = value;
				}
			}
		}

		private static void ApplyValuableDebugMode(ValuableDirector director, List<ValuableVolume> allVolumes, List<ValuableVolume> tinyVolumes, List<ValuableVolume> smallVolumes, List<ValuableVolume> mediumVolumes, List<ValuableVolume> bigVolumes, List<ValuableVolume> wideVolumes, List<ValuableVolume> tallVolumes, List<ValuableVolume> veryTallVolumes, WeightedPoolSet poolSet)
		{
			string fieldValueAsString = GetFieldValueAsString(ValuableDebugField, director);
			if (string.Equals(fieldValueAsString, "All", StringComparison.OrdinalIgnoreCase))
			{
				SetFieldValue(TotalMaxAmountField, director, allVolumes.Count);
				SetFieldValue(TotalMaxValueField, director, 99999f);
				SetFieldValue(TinyMaxAmountField, director, tinyVolumes.Count);
				SetFieldValue(SmallMaxAmountField, director, smallVolumes.Count);
				SetFieldValue(MediumMaxAmountField, director, mediumVolumes.Count);
				SetFieldValue(BigMaxAmountField, director, bigVolumes.Count);
				SetFieldValue(WideMaxAmountField, director, wideVolumes.Count);
				SetFieldValue(TallMaxAmountField, director, tallVolumes.Count);
				SetFieldValue(VeryTallMaxAmountField, director, veryTallVolumes.Count);
			}
			if (string.Equals(fieldValueAsString, "None", StringComparison.OrdinalIgnoreCase) || poolSet == null || poolSet.IsCompletelyEmpty())
			{
				SetAllMaxAmounts(director, 0);
			}
		}

		private static int SelectCategoryIndex(int[] maxAmounts, int[] volumeIndex, List<ValuableVolume>[] volumeLists, List<WeightedPrefabRef>[] weightedPools, int[] chances)
		{
			float num = -1f;
			int result = -1;
			for (int i = 0; i < volumeLists.Length; i++)
			{
				if (volumeIndex[i] < maxAmounts[i] && volumeLists[i] != null && volumeIndex[i] < volumeLists[i].Count && weightedPools[i] != null && weightedPools[i].Count != 0)
				{
					int num2 = Random.Range(0, Mathf.Max(1, chances[i]));
					if ((float)num2 > num)
					{
						num = num2;
						result = i;
					}
				}
			}
			return result;
		}

		private static WeightedPrefabRef PickWeightedPrefab(List<WeightedPrefabRef> weightedPool)
		{
			if (weightedPool == null || weightedPool.Count == 0)
			{
				return null;
			}
			int num = 0;
			foreach (WeightedPrefabRef item in weightedPool)
			{
				if (item != null && item.PrefabRef != null && item.Weight > 0)
				{
					num += item.Weight;
				}
			}
			if (num <= 0)
			{
				return null;
			}
			int num2 = Random.Range(0, num);
			int num3 = 0;
			foreach (WeightedPrefabRef item2 in weightedPool)
			{
				if (item2 != null && item2.PrefabRef != null && item2.Weight > 0)
				{
					num3 += item2.Weight;
					if (num2 < num3)
					{
						return item2;
					}
				}
			}
			return weightedPool[weightedPool.Count - 1];
		}

		private static void InvokeSpawnValuable(ValuableDirector director, PrefabRef prefabRef, ValuableVolume volume, string path)
		{
			SpawnValuableMethod.Invoke(director, new object[3] { prefabRef, volume, path });
		}

		private static void WriteSpawnShortageLog(ValuableDirector director, int[] maxAmounts, int[] volumeIndex)
		{
			if ((Object)(object)AllMapValuablesPlugin.Instance == (Object)null || !AllMapValuablesPlugin.Instance.IsVerboseLogEnabled())
			{
				return;
			}
			int fieldValue = GetFieldValue<int>(ValuableTargetAmountField, director);
			int fieldValue2 = GetFieldValue<int>(TotalMaxAmountField, director);
			if (fieldValue >= fieldValue2)
			{
				return;
			}
			string[] array = new string[7] { "Tiny", "Small", "Medium", "Big", "Wide", "Tall", "Very Tall" };
			for (int i = 0; i < array.Length; i++)
			{
				if (volumeIndex[i] < maxAmounts[i])
				{
					AllMapValuablesPlugin.WriteWarning("Could not spawn enough " + array[i] + " valuables.");
				}
			}
		}

		private static void RpcTargetAmount(ValuableDirector director, string rpcName, int targetAmount)
		{
			if (IsMultiplayerRoomActive())
			{
				PhotonView component = ((Component)director).GetComponent<PhotonView>();
				if (!((Object)(object)component == (Object)null))
				{
					component.RPC(rpcName, (RpcTarget)0, new object[1] { targetAmount });
				}
			}
		}

		private static void RunCosmeticWorldObjectSetup(ValuableDirector director, int[] volumeIndex, List<ValuableVolume>[] volumeLists)
		{
			if (CosmeticWorldObjectTargetAmountField == null || CosmeticWorldObjectSpawnPlayerReadyField == null)
			{
				return;
			}
			SetFieldValue(CosmeticWorldObjectTargetAmountField, director, 0);
			try
			{
				if (SpawnCosmeticWorldObjectMethod == null || CosmeticWorldObjectDebugField == null)
				{
					SetCosmeticWorldObjectTargetZero(director);
					return;
				}
				string fieldValueAsString = GetFieldValueAsString(CosmeticWorldObjectDebugField, director);
				if (string.Equals(fieldValueAsString, "Normal", StringComparison.OrdinalIgnoreCase) && SemiFunc.RunIsLevel())
				{
					RunNormalCosmeticWorldObjectSetup(director, volumeIndex, volumeLists);
				}
				else if (string.Equals(fieldValueAsString, "All", StringComparison.OrdinalIgnoreCase))
				{
					InvokeSpawnCosmeticWorldObjectByName(director, "Common", volumeIndex, volumeLists);
					InvokeSpawnCosmeticWorldObjectByName(director, "Uncommon", volumeIndex, volumeLists);
					InvokeSpawnCosmeticWorldObjectByName(director, "Rare", volumeIndex, volumeLists);
					InvokeSpawnCosmeticWorldObjectByName(director, "UltraRare", volumeIndex, volumeLists);
				}
				RpcTargetAmount(director, "CosmeticWorldObjectTargetSetRPC", GetFieldValue<int>(CosmeticWorldObjectTargetAmountField, director));
				IncrementIntField(CosmeticWorldObjectSpawnPlayerReadyField, director);
			}
			catch (Exception ex)
			{
				AllMapValuablesPlugin.WriteWarning("Failure: Cosmetic world object reflection setup failed. Cosmetic target is set to 0.\n" + ex);
				SetCosmeticWorldObjectTargetZero(director);
			}
		}

		private static void RunNormalCosmeticWorldObjectSetup(ValuableDirector director, int[] volumeIndex, List<ValuableVolume>[] volumeLists)
		{
			if (CosmeticWorldObjectSetupsField == null || CosmeticWorldObjectsSpawnCurveField == null)
			{
				return;
			}
			int num = InvokeIntMethod(CosmeticWorldObjectLevelLoopsGetMethod, director, 0);
			int num2 = InvokeIntMethod(CosmeticWorldObjectLevelLoopsClampedGetMethod, director, 0);
			int num3 = Mathf.Max(1, GetFieldValue<int>(CosmeticWorldObjectsLevelLoopField, director));
			AnimationCurve fieldValue = GetFieldValue<AnimationCurve>(CosmeticWorldObjectsSpawnCurveField, director);
			if (fieldValue == null)
			{
				return;
			}
			for (int i = 0; i <= num2; i++)
			{
				float num4;
				if (i < num)
				{
					num4 = 1f;
				}
				else
				{
					int num5 = (((Object)(object)RunManager.instance != (Object)null) ? RunManager.instance.levelsCompleted : 0);
					num4 = (float)(num5 % num3) / (float)num3;
				}
				int num6 = Mathf.RoundToInt(fieldValue.Evaluate(num4) * 100f);
				int runManagerBadLuckCount = GetRunManagerBadLuckCount();
				if (runManagerBadLuckCount > 0)
				{
					num6 += Mathf.RoundToInt((float)runManagerBadLuckCount * 20f);
				}
				if (Random.Range(0, 100) < num6)
				{
					object obj = PickCosmeticRarityByCurve(director, num4);
					if (obj != null)
					{
						InvokeSpawnCosmeticWorldObject(director, obj, volumeIndex, volumeLists);
					}
				}
			}
			if (GetFieldValue<int>(CosmeticWorldObjectTargetAmountField, director) <= 0)
			{
				SetRunManagerBadLuckCount(GetRunManagerBadLuckCount() + 1);
			}
		}

		private static object PickCosmeticRarityByCurve(ValuableDirector director, float curveTime)
		{
			IList fieldValue = GetFieldValue<IList>(CosmeticWorldObjectSetupsField, director);
			if (fieldValue == null || fieldValue.Count == 0)
			{
				return null;
			}
			object result = null;
			float num = -1f;
			foreach (object item in fieldValue)
			{
				if (item == null)
				{
					continue;
				}
				FieldInfo fieldInfo = AccessTools.Field(item.GetType(), "chanceCurve");
				FieldInfo fieldInfo2 = AccessTools.Field(item.GetType(), "rarity");
				if (fieldInfo == null || fieldInfo2 == null)
				{
					continue;
				}
				object? value = fieldInfo.GetValue(item);
				AnimationCurve val = (AnimationCurve)((value is AnimationCurve) ? value : null);
				if (val == null)
				{
					continue;
				}
				int num2 = Mathf.RoundToInt(val.Evaluate(curveTime) * 100f);
				if (num2 > 0)
				{
					int num3 = Random.Range(0, num2);
					if ((float)num3 > num)
					{
						num = num3;
						result = fieldInfo2.GetValue(item);
					}
				}
			}
			return result;
		}

		private static void InvokeSpawnCosmeticWorldObjectByName(ValuableDirector director, string rarityName, int[] volumeIndex, List<ValuableVolume>[] volumeLists)
		{
			object cosmeticRarityEnumValue = GetCosmeticRarityEnumValue(rarityName);
			if (cosmeticRarityEnumValue != null)
			{
				InvokeSpawnCosmeticWorldObject(director, cosmeticRarityEnumValue, volumeIndex, volumeLists);
			}
		}

		private static object GetCosmeticRarityEnumValue(string rarityName)
		{
			if (SpawnCosmeticWorldObjectMethod == null)
			{
				return null;
			}
			ParameterInfo[] parameters = SpawnCosmeticWorldObjectMethod.GetParameters();
			if (parameters == null || parameters.Length == 0 || parameters[0] == null || !parameters[0].ParameterType.IsEnum)
			{
				return null;
			}
			try
			{
				return Enum.Parse(parameters[0].ParameterType, rarityName);
			}
			catch
			{
				return null;
			}
		}

		private static void InvokeSpawnCosmeticWorldObject(ValuableDirector director, object rarityValue, int[] volumeIndex, List<ValuableVolume>[] volumeLists)
		{
			if (!(SpawnCosmeticWorldObjectMethod == null) && rarityValue != null)
			{
				SpawnCosmeticWorldObjectMethod.Invoke(director, new object[3] { rarityValue, volumeIndex, volumeLists });
			}
		}

		private static int InvokeIntMethod(MethodInfo methodInfo, object instance, int fallbackValue)
		{
			if (methodInfo == null || instance == null)
			{
				return fallbackValue;
			}
			if (!(methodInfo.Invoke(instance, Array.Empty<object>()) is int result))
			{
				return fallbackValue;
			}
			return result;
		}

		private static int GetRunManagerBadLuckCount()
		{
			if ((Object)(object)RunManager.instance == (Object)null || RunManagerCosmeticWorldObjectBadLuckCountField == null)
			{
				return 0;
			}
			if (!(RunManagerCosmeticWorldObjectBadLuckCountField.GetValue(RunManager.instance) is int result))
			{
				return 0;
			}
			return result;
		}

		private static void SetRunManagerBadLuckCount(int value)
		{
			if (!((Object)(object)RunManager.instance == (Object)null) && !(RunManagerCosmeticWorldObjectBadLuckCountField == null))
			{
				RunManagerCosmeticWorldObjectBadLuckCountField.SetValue(RunManager.instance, value);
			}
		}

		private static void SetCosmeticWorldObjectTargetZero(ValuableDirector director)
		{
			SetFieldValue(CosmeticWorldObjectTargetAmountField, director, 0);
			RpcTargetAmount(director, "CosmeticWorldObjectTargetSetRPC", 0);
			IncrementIntField(CosmeticWorldObjectSpawnPlayerReadyField, director);
		}

		private static bool IsMultiplayerRoomActive()
		{
			return (Object)(object)GameManager.instance != (Object)null && GameManager.instance.gameMode == 1 && PhotonNetwork.CurrentRoom != null;
		}

		private static void IncrementIntField(FieldInfo fieldInfo, object instance)
		{
			if (!(fieldInfo == null) && instance != null)
			{
				int fieldValue = GetFieldValue<int>(fieldInfo, instance);
				SetFieldValue(fieldInfo, instance, fieldValue + 1);
			}
		}

		private static string GetFieldValueAsString(FieldInfo fieldInfo, object instance)
		{
			if (fieldInfo == null || instance == null)
			{
				return string.Empty;
			}
			object value = fieldInfo.GetValue(instance);
			return (value == null) ? string.Empty : value.ToString();
		}

		private static T GetFieldValue<T>(FieldInfo fieldInfo, object instance)
		{
			if (fieldInfo == null || instance == null)
			{
				return default(T);
			}
			object value = fieldInfo.GetValue(instance);
			if (value == null)
			{
				return default(T);
			}
			return (T)value;
		}

		private static void SetFieldValue(FieldInfo fieldInfo, object instance, object value)
		{
			if (!(fieldInfo == null) && instance != null)
			{
				fieldInfo.SetValue(instance, value);
			}
		}
	}
}