using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AutogenRundown.DataBlocks;
using AutogenRundown.DataBlocks.Alarms;
using AutogenRundown.DataBlocks.Enemies;
using AutogenRundown.DataBlocks.Items;
using AutogenRundown.DataBlocks.Levels;
using AutogenRundown.DataBlocks.Objectives;
using AutogenRundown.DataBlocks.Objectives.Reactor;
using AutogenRundown.DataBlocks.ZoneData;
using AutogenRundown.DataBlocks.Zones;
using AutogenRundown.GeneratorData;
using AutogenRundown.Patches;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using CellMenu;
using HarmonyLib;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using TMPro;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("AutogenRundown")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+f78a8b329c765b66e1f4c719687e392be773e085")]
[assembly: AssemblyProduct("AutogenRundown")]
[assembly: AssemblyTitle("AutogenRundown")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace AutogenRundown
{
	public enum Complexity
	{
		Low,
		Medium,
		High
	}
	public enum MissionSize
	{
		Low,
		Medium,
		High
	}
	public class BuildDirector
	{
		public int Points { get; set; }

		public Complexity Complexity { get; set; } = Complexity.Medium;


		public string Tier { get; set; } = "A";


		public Bulkhead Bulkhead { get; set; } = Bulkhead.Main;


		public Complex Complex { get; set; }

		public LevelSettings Settings { get; set; } = new LevelSettings();


		public WardenObjectiveType Objective { get; set; } = WardenObjectiveType.GatherSmallItems;


		public int ZoneCount { get; set; }

		public List<int> EnemyPointPool { get; set; } = new List<int>();


		public void GenObjective(IEnumerable<WardenObjectiveType> exclude)
		{
			IEnumerable<WardenObjectiveType> exclude2 = exclude;
			List<WardenObjectiveType> list = new List<WardenObjectiveType>
			{
				WardenObjectiveType.HsuFindSample,
				WardenObjectiveType.ReactorStartup,
				WardenObjectiveType.ReactorShutdown,
				WardenObjectiveType.GatherSmallItems,
				WardenObjectiveType.ClearPath,
				WardenObjectiveType.SpecialTerminalCommand,
				WardenObjectiveType.RetrieveBigItems,
				WardenObjectiveType.PowerCellDistribution,
				WardenObjectiveType.TerminalUplink
			};
			list.RemoveAll((WardenObjectiveType o) => exclude2.Contains(o));
			if (!Bulkhead.HasFlag(Bulkhead.Main))
			{
				list.Remove(WardenObjectiveType.ClearPath);
				list.Remove(WardenObjectiveType.PowerCellDistribution);
			}
			if (Bulkhead.HasFlag(Bulkhead.Main))
			{
				list.Remove(WardenObjectiveType.SpecialTerminalCommand);
			}
			if (Complex != Complex.Mining || Complex != Complex.Tech)
			{
				list.Remove(WardenObjectiveType.ReactorStartup);
				list.Remove(WardenObjectiveType.ReactorShutdown);
				list.Remove(WardenObjectiveType.CentralGeneratorCluster);
			}
			Objective = Generator.Pick(list);
		}

		public void GenPoints()
		{
			string tier = Tier;
			Bulkhead bulkhead = Bulkhead;
			int points;
			switch (tier)
			{
			case "A":
				switch (bulkhead)
				{
				case Bulkhead.Main:
					break;
				case Bulkhead.Extreme:
					goto IL_010a;
				case Bulkhead.Overload:
					goto IL_0132;
				default:
					goto IL_015a;
				}
				points = 400;
				break;
			case "B":
				switch (bulkhead)
				{
				case Bulkhead.Main:
					break;
				case Bulkhead.Extreme:
					goto IL_0112;
				case Bulkhead.Overload:
					goto IL_013a;
				default:
					goto IL_015a;
				}
				points = 500;
				break;
			case "C":
				switch (bulkhead)
				{
				case Bulkhead.Main:
					break;
				case Bulkhead.Extreme:
					goto IL_011a;
				case Bulkhead.Overload:
					goto IL_0142;
				default:
					goto IL_015a;
				}
				points = 800;
				break;
			case "D":
				switch (bulkhead)
				{
				case Bulkhead.Main:
					break;
				case Bulkhead.Extreme:
					goto IL_0122;
				case Bulkhead.Overload:
					goto IL_014a;
				default:
					goto IL_015a;
				}
				points = 800;
				break;
			case "E":
				switch (bulkhead)
				{
				case Bulkhead.Main:
					break;
				case Bulkhead.Extreme:
					goto IL_012a;
				case Bulkhead.Overload:
					goto IL_0152;
				default:
					goto IL_015a;
				}
				points = 800;
				break;
			default:
				goto IL_015a;
				IL_0152:
				points = 800;
				break;
				IL_012a:
				points = 800;
				break;
				IL_014a:
				points = 800;
				break;
				IL_0122:
				points = 800;
				break;
				IL_015a:
				points = 600;
				break;
				IL_0142:
				points = 800;
				break;
				IL_011a:
				points = 800;
				break;
				IL_0132:
				points = 400;
				break;
				IL_013a:
				points = 500;
				break;
				IL_0112:
				points = 500;
				break;
				IL_010a:
				points = 400;
				break;
			}
			Points = points;
		}

		public void GenZones()
		{
			string tier = Tier;
			Bulkhead bulkhead = Bulkhead;
			ZoneCount = tier switch
			{
				"A" => (bulkhead != Bulkhead.Main) ? Generator.Random.Next(2, 3) : Generator.Random.Next(4, 5), 
				"B" => (bulkhead != Bulkhead.Main) ? Generator.Random.Next(2, 3) : Generator.Random.Next(5, 6), 
				"C" => (bulkhead != Bulkhead.Main) ? Generator.Random.Next(2, 4) : Generator.Random.Next(6, 7), 
				"D" => (bulkhead != Bulkhead.Main) ? Generator.Random.Next(3, 5) : Generator.Random.Next(6, 7), 
				"E" => (bulkhead != Bulkhead.Main) ? Generator.Random.Next(3, 5) : Generator.Random.Next(7, 9), 
				_ => 1, 
			};
			EnemyPointPool = (from _ in Enumerable.Range(0, ZoneCount)
				select Points / ZoneCount).ToList();
		}

		public int GetPoints(Zone zone)
		{
			double num = (zone.Coverage.Min + zone.Coverage.Max) / 2.0 / 30.0;
			return (int)(num * (double)(Tier switch
			{
				"A" => Generator.Random.Next(15, 25), 
				"B" => Generator.Random.Next(20, 25), 
				"C" => Generator.Random.Next(20, 30), 
				"D" => Generator.Random.Next(30, 35), 
				"E" => Generator.Random.Next(35, 40), 
				_ => 25, 
			}));
		}
	}
	public class Collections
	{
		public static List<T> Flatten<T>(params ICollection<T>[] collections)
		{
			return collections.SelectMany((ICollection<T> c) => c).ToList();
		}
	}
	public static class Text
	{
		public static string ToRoman(int number)
		{
			if (number < 0 || number > 3999)
			{
				throw new ArgumentOutOfRangeException("number", "insert value between 1 and 3999");
			}
			if (number < 1)
			{
				return string.Empty;
			}
			if (number >= 1000)
			{
				return "M" + ToRoman(number - 1000);
			}
			if (number >= 900)
			{
				return "CM" + ToRoman(number - 900);
			}
			if (number >= 500)
			{
				return "D" + ToRoman(number - 500);
			}
			if (number >= 400)
			{
				return "CD" + ToRoman(number - 400);
			}
			if (number >= 100)
			{
				return "C" + ToRoman(number - 100);
			}
			if (number >= 90)
			{
				return "XC" + ToRoman(number - 90);
			}
			if (number >= 50)
			{
				return "L" + ToRoman(number - 50);
			}
			if (number >= 40)
			{
				return "XL" + ToRoman(number - 40);
			}
			if (number >= 10)
			{
				return "X" + ToRoman(number - 10);
			}
			if (number >= 9)
			{
				return "IX" + ToRoman(number - 9);
			}
			if (number >= 5)
			{
				return "V" + ToRoman(number - 5);
			}
			if (number >= 4)
			{
				return "IV" + ToRoman(number - 4);
			}
			if (number >= 1)
			{
				return "I" + ToRoman(number - 1);
			}
			return "";
		}
	}
	public enum PidOffsets
	{
		None,
		Normal,
		EnemyGroup,
		WavePopulation,
		WaveSettings
	}
	public static class Generator
	{
		public interface ISelectable
		{
			double Weight { get; set; }
		}

		private static uint pid = 100000u;

		private static uint enemyGroupPid = 80u;

		private static uint wavePopulationPid = 100u;

		private static uint waveSettingsPid = 400u;

		public static string DisplaySeed { get; set; } = "";


		public static string Seed { get; set; } = "";


		public static Random Random { get; private set; } = new Random();


		public static double NextDouble()
		{
			return Random.NextDouble();
		}

		public static double NextDouble(double min, double max)
		{
			return Random.NextDouble() * (max - min) + min;
		}

		public static double NextDouble(double max)
		{
			return Random.NextDouble() * max;
		}

		public static bool Flip(double chance = 0.5)
		{
			return Random.NextDouble() < chance;
		}

		public static T? Pick<T>(IEnumerable<T> collection)
		{
			if (collection.Count() <= 0)
			{
				return default(T);
			}
			return collection.ElementAt(Random.Next(collection.Count()));
		}

		public static T? Draw<T>(ICollection<T> collection)
		{
			T val = Pick(collection);
			if (val != null)
			{
				collection.Remove(val);
			}
			return val;
		}

		public static List<T> Shuffle<T>(ICollection<T> collection)
		{
			return collection.OrderBy((T _) => Random.Next()).ToList();
		}

		public static T Select<T>(ICollection<T> collection) where T : ISelectable
		{
			double num = collection.Sum((T x) => x.Weight);
			double num2 = Random.NextDouble() * num;
			double num3 = 0.0;
			foreach (T item in collection)
			{
				num3 += item.Weight;
				if (num2 <= num3)
				{
					return item;
				}
			}
			return collection.Last();
		}

		public static T Select<T>(ICollection<(double, T)> collection)
		{
			double num = collection.Sum<(double, T)>(((double, T) x) => x.Item1);
			double num2 = Random.NextDouble() * num;
			double num3 = 0.0;
			foreach (var item3 in collection)
			{
				double item = item3.Item1;
				T item2 = item3.Item2;
				num3 += item;
				if (num2 <= num3)
				{
					return item2;
				}
			}
			return collection.Last().Item2;
		}

		public static uint GetPersistentId(PidOffsets offset = PidOffsets.Normal)
		{
			switch (offset)
			{
			case PidOffsets.None:
				return 0u;
			case PidOffsets.Normal:
				return pid++;
			case PidOffsets.EnemyGroup:
				return enemyGroupPid++;
			case PidOffsets.WavePopulation:
				return wavePopulationPid++;
			case PidOffsets.WaveSettings:
				return waveSettingsPid++;
			default:
			{
				global::<PrivateImplementationDetails>.ThrowSwitchExpressionException(offset);
				uint result = default(uint);
				return result;
			}
			}
		}

		public static void GenerateTimeSeed()
		{
			DateTime utcNow = DateTime.UtcNow;
			TimeZoneInfo destinationTimeZone = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
			DateTime dateTime = TimeZoneInfo.ConvertTimeFromUtc(utcNow, destinationTimeZone);
			string seed = dateTime.ToString("yyyy_MM_dd");
			string text = dateTime.ToString("MM/dd");
			Seed = seed;
			DisplaySeed = "<color=orange>" + text + "</color>";
		}

		public static void RegenerateSeed()
		{
			Seed = $"{GetWord()}_{GetWord()}_{GetWord()}";
			DisplaySeed = Seed;
			WriteSeed();
			Reload();
			static string GetWord()
			{
				string text = Pick(Words.SeedWords);
				return text.Substring(0, 1).ToUpper() + text.Substring(1);
			}
		}

		public static void Reload()
		{
			Random = new Random(GetHashCode(Seed));
		}

		public static void ReadOrSetSeed(string seed = "")
		{
			if (seed != "")
			{
				Seed = seed;
			}
			else
			{
				GenerateTimeSeed();
			}
		}

		public static void WriteSeed()
		{
			string text = Path.Combine(Paths.PluginPath, "MyFirstPlugin");
			string path = Path.Combine(text, "seed.txt");
			Directory.CreateDirectory(text);
			using FileStream stream = File.Create(path);
			using StreamWriter streamWriter = new StreamWriter(stream);
			streamWriter.WriteLine(Seed);
		}

		private static int GetHashCode(this string str)
		{
			int num = 5381;
			int num2 = num;
			for (int i = 0; i < str.Length && str[i] != 0; i += 2)
			{
				num = ((num << 5) + num) ^ str[i];
				if (i == str.Length - 1 || str[i + 1] == '\0')
				{
					break;
				}
				num2 = ((num2 << 5) + num2) ^ str[i + 1];
			}
			return num + num2 * 1566083941;
		}
	}
	[BepInPlugin("AutogenRundown", "AutogenRundown", "0.18.1")]
	[BepInProcess("GTFO.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		public const string Version = "0.18.1";

		public static ManualLogSource Logger { get; private set; } = new ManualLogSource("MyFirstPlugin");


		public override void Load()
		{
			//IL_002b: 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_004a: Expected O, but got Unknown
			//IL_004a: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Expected O, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: Expected O, but got Unknown
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Expected O, but got Unknown
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BasePlugin)this).Log;
			((BasePlugin)this).Log.LogInfo((object)"Startup...");
			ConfigEntry<string> val = ((BasePlugin)this).Config.Bind<string>(new ConfigDefinition("AutogenRundown", "Seed"), "", new ConfigDescription("Specify a seed to override rundown generation", (AcceptableValueBase)null, Array.Empty<object>()));
			ConfigEntry<bool> val2 = ((BasePlugin)this).Config.Bind<bool>(new ConfigDefinition("AutogenRundown", "RegenerateOnStartup"), true, new ConfigDescription("Should datablocks be regenerated on game startup.", (AcceptableValueBase)null, Array.Empty<object>()));
			ManualLogSource log = ((BasePlugin)this).Log;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val3 = new BepInExInfoLogInterpolatedStringHandler(13, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("ConfigSeed=\"");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(val.Value);
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("\"");
			}
			log.LogInfo(val3);
			ManualLogSource log2 = ((BasePlugin)this).Log;
			val3 = new BepInExInfoLogInterpolatedStringHandler(20, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("RegenerateOnStartup=");
				((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<bool>(val2.Value);
			}
			log2.LogInfo(val3);
			Generator.ReadOrSetSeed(val.Value);
			if (val2.Value)
			{
				RundownFactory.Build();
				ManualLogSource log3 = ((BasePlugin)this).Log;
				val3 = new BepInExInfoLogInterpolatedStringHandler(26, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("Rundown generated, Seed=\"");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(Generator.Seed);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("\"");
				}
				log3.LogInfo(val3);
			}
			else
			{
				ManualLogSource log4 = ((BasePlugin)this).Log;
				val3 = new BepInExInfoLogInterpolatedStringHandler(30, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("Rundown not generated, Seed=\"");
					((BepInExLogInterpolatedStringHandler)val3).AppendFormatted<string>(Generator.Seed);
					((BepInExLogInterpolatedStringHandler)val3).AppendLiteral("\"");
				}
				log4.LogInfo(val3);
			}
			PlayFabManager.OnTitleDataUpdated += Action.op_Implicit((Action)RundownNames.OnTitleDataUpdated);
			new Harmony("AutogenRundown").PatchAll();
		}
	}
	public static class RundownFactory
	{
		public static bool JsonDataExists()
		{
			if (Generator.Seed == "")
			{
				return false;
			}
			return Directory.Exists(Path.Combine(Paths.PluginPath, "MyFirstPlugin", "Datablocks", Generator.Seed));
		}

		public static void Build()
		{
			Generator.Reload();
			Bins.Setup();
			Rundown rundown = Rundown.Build(new Rundown
			{
				PersistentId = Rundown.R7
			});
			List<string> collection = new List<string>(Words.NounsLevel);
			int num = Generator.Random.Next(1, 2);
			int num2 = Generator.Random.Next(3, 4);
			int num3 = Generator.Random.Next(2, 4);
			int num4 = Generator.Random.Next(2, 4);
			int num5 = Generator.Random.Next(1, 2);
			for (int i = 0; i < num; i++)
			{
				Level level = Level.Build(new Level
				{
					Tier = "A",
					Name = Generator.Draw(collection),
					Index = i + 1
				});
				rundown.AddLevel(level);
			}
			for (int j = 0; j < num2; j++)
			{
				Level level2 = Level.Build(new Level
				{
					Tier = "B",
					Name = Generator.Draw(collection),
					Index = j + 1
				});
				rundown.AddLevel(level2);
			}
			for (int k = 0; k < num3; k++)
			{
				Level level3 = Level.Build(new Level
				{
					Tier = "C",
					Name = Generator.Draw(collection),
					Index = k + 1
				});
				rundown.AddLevel(level3);
			}
			BuildDirector buildDirector = new BuildDirector
			{
				Bulkhead = Bulkhead.Main,
				Complex = Complex.Mining,
				Complexity = Complexity.Low,
				Tier = "C",
				Objective = WardenObjectiveType.ReactorStartup
			};
			buildDirector.GenPoints();
			LevelSettings levelSettings = new LevelSettings("C");
			levelSettings.Modifiers.Add(LevelModifiers.Fog);
			Level level4 = Level.Build(new Level
			{
				Tier = "C",
				Name = "Reactor Startup",
				Complex = Complex.Mining,
				MainDirector = buildDirector,
				Settings = levelSettings,
				Index = num3 + 1,
				IsTest = true
			});
			rundown.AddLevel(level4);
			for (int l = 0; l < num4; l++)
			{
				Level level5 = Level.Build(new Level
				{
					Tier = "D",
					Name = Generator.Draw(collection),
					Index = l + 1
				});
				rundown.AddLevel(level5);
			}
			for (int m = 0; m < num5; m++)
			{
				Level level6 = Level.Build(new Level
				{
					Tier = "E",
					Name = Generator.Draw(collection),
					Index = m + 1
				});
				rundown.AddLevel(level6);
			}
			Bins.Rundowns.AddBlock(rundown);
			Bins.Rundowns.AddBlock(new Rundown
			{
				PersistentId = Rundown.R1,
				Name = "ALT Rundown 1.0"
			});
			Bins.Rundowns.AddBlock(new Rundown
			{
				PersistentId = Rundown.R2,
				Name = "ALT Rundown 2.0"
			});
			Bins.Rundowns.AddBlock(new Rundown
			{
				PersistentId = Rundown.R3,
				Name = "ALT Rundown 3.0"
			});
			Bins.Rundowns.AddBlock(new Rundown
			{
				PersistentId = Rundown.R4,
				Name = "ALT Rundown 4.0"
			});
			Bins.Rundowns.AddBlock(new Rundown
			{
				PersistentId = Rundown.R5,
				Name = "ALT Rundown 5.0"
			});
			Bins.Rundowns.AddBlock(new Rundown
			{
				PersistentId = Rundown.R6,
				Name = "ALT Rundown 6.0"
			});
			Bins.Rundowns.AddBlock(new Rundown
			{
				PersistentId = Rundown.R7,
				Name = "Rundown 7.0"
			});
			Bins.Rundowns.AddBlock(new Rundown
			{
				PersistentId = Rundown.R8,
				Name = "Rundown 8.0"
			});
			Bins.Rundowns.AddBlock(new Rundown
			{
				PersistentId = Rundown.Tutorial,
				Name = "Tutorial"
			});
			Bins.Rundowns.AddBlock(new Rundown
			{
				PersistentId = Rundown.Geomorph,
				Name = "Geomorph"
			});
			Bins.Save();
		}
	}
	public class WeightedValue<T> : Generator.ISelectable
	{
		public double Weight { get; set; } = 1.0;


		public T? Value { get; set; }
	}
}
namespace AutogenRundown.Patches
{
	public class RundownNames
	{
		public static void OnTitleDataUpdated()
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			Enumerator<CM_RundownSelection> enumerator = MainMenuGuiLayer.Current.PageRundownNew.m_rundownSelections.GetEnumerator();
			while (enumerator.MoveNext())
			{
				CM_RundownSelection current = enumerator.Current;
				if ((Object)current.m_altText != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)current.m_altText).gameObject);
				}
				if (num == 1)
				{
					Rundown rundown = Bins.Rundowns.Find(Rundown.R7);
					((TMP_Text)current.m_rundownText).text = "<size=60%><color=green>RND://</color></size>R" + rundown?.DisplaySeed;
				}
				else
				{
					((CM_Item)current).SetButtonEnabled(false);
					current.SetIsUsed(false);
					((TMP_Text)current.m_rundownText).text = "";
				}
				num++;
			}
		}
	}
	[HarmonyPatch(typeof(PUI_Watermark), "UpdateWatermark")]
	public class Watermark
	{
		[HarmonyAfter(new string[] { "com.dak.MTFO" })]
		public static void Postfix(PUI_Watermark __instance)
		{
			((TMP_Text)__instance.m_watermarkText).SetText($"<size=14>Seed <color=orange>{Generator.Seed}</color>\nAR v{"0.18.1"}</size>", true);
		}
	}
}
namespace AutogenRundown.GeneratorData
{
	public static class Words
	{
		public static string[] Adjectives = new string[200]
		{
			"Bleak", "Ruthless", "Morbid", "Desolate", "Brutal", "Malignant", "Forsaken", "Grotesque", "Dystopian", "Hollow",
			"Gruesome", "Harrowing", "Malevolent", "Oppressive", "Visceral", "Mutilated", "Cursed", "Macabre", "Noxious", "Tormented",
			"Ominous", "Rancid", "Suffering", "Wretched", "Sinister", "Melancholic", "Feral", "Mournful", "Pernicious", "Bleeding",
			"Carnal", "Decayed", "Malformed", "Savage", "Ravaged", "Corroded", "Vile", "Tainted", "Blighted", "Fetid",
			"Grim", "Unholy", "Nefarious", "Blasphemous", "Abominable", "Haunting", "Deathly", "Charnel", "Abyssal", "Ghastly",
			"Insidious", "Foreboding", "Eroded", "Lamentable", "Sepulchral", "Dismal", "Rotten", "Drab", "Infested", "Profane",
			"Grisly", "Terrifying", "Desecrated", "Dire", "Maddening", "Gory", "Searing", "Putrid", "Cadaverous", "Gaunt",
			"Soulless", "Ashen", "Deranged", "Murky", "Sullied", "Decrepit", "Ruinous", "Morose", "Piteous", "Calamitous",
			"Lurid", "Bleached", "Tenebrous", "Anguished", "Ravenous", "Unsettling", "Marred", "Disquieting", "Dreadful", "Malign",
			"Stifling", "Pervasive", "Gloom-ridden", "Stark", "Bereft", "Shattered", "Broken", "Eviscerated", "Cacophonous", "Grimy",
			"Disturbing", "Shadowy", "War-torn", "Cataclysmic", "Waning", "Bane-filled", "Doomed", "Catastrophic", "Muted", "Festering",
			"Barren", "Fading", "Atrophied", "Diminished", "Eerie", "Discordant", "Tumultuous", "Raving", "Merciless", "Malefic",
			"Crumbling", "Haggard", "Pained", "Ravishing", "Venomous", "Withered", "Spiteful", "Obsidian", "Battered", "Appalling",
			"Unrelenting", "Bloodthirsty", "Sable", "Annihilated", "Drowning", "Sanguine", "Infernal", "Tortured", "Scarred", "Searing",
			"Horrifying", "Blackened", "Splintered", "Enervated", "Heinous", "Smoldering", "Pestilent", "Accursed", "Frenzied", "Decimating",
			"Fractured", "Toxic", "Pallid", "Despairing", "Despondent", "Relentless", "Wailing", "Traumatized", "Ravaging", "Twisted",
			"Seething", "Caustic", "Scorched", "Tattered", "Lecherous", "Vexed", "Void", "Wounded", "Befouled", "Stricken",
			"Degenerate", "Consumed", "Demonic", "Raging", "Vitiated", "Corrupted", "Hellish", "Purgatorial", "Defiled", "Repugnant",
			"Sacrilegious", "Blasted", "Bewitched", "Entropic", "Deteriorated", "Wrathful", "Plagued", "Waning", "Brooding", "Abject",
			"Disheveled", "Chilling", "Loathsome", "Maddened", "Melting", "Perishing", "Throttled", "Eclipsed", "Shriveling", "Maleficent"
		};

		public static string[] NounsRundown = new string[50]
		{
			"Abyss", "Chasm", "Void", "Maw", "Underworld", "Cavern", "Labyrinth", "Catacomb", "Pitfall", "Gorge",
			"Hollow", "Subterrane", "Burrow", "Crevasse", "Gullet", "Tenebrous Tunnel", "Darkwell", "Fissure", "Undercrypt", "Oblivion",
			"Crusade", "Vendetta", "Ordeal", "Bloodquest", "Reckoning", "Purge", "Conquest", "Expurgation", "Vengeance", "Retribution",
			"Endeavor", "Extermination", "Annihilation", "Obliteration", "Decimation", "Dominion", "Insurrection", "Onslaught", "Sacrifice", "Inquisition",
			"Siege", "Desolation", "Persecution", "Incursion", "Culling", "Exorcism", "Enthronement", "Subjugation", "Redemption", "Ravage"
		};

		public static string[] NounsLevel = new string[115]
		{
			"Dissolution", "Enigma Void", "Malevolence", "Bleak Nexus", "Catacomb Depth", "Aberration", "Desolation Pulse", "Grim Ascent", "Cryptic Relic", "Shadow's Descent",
			"Forlorn Vault", "Abyssal Rift", "Blight's Reach", "Mire", "Decay's Hold", "Obliterate", "Infernal Passage", "Isolation", "Torment's Lair", "Veil of Despair",
			"Sable Depths", "Entropy's Grasp", "Lost Reverie", "Despair's Domain", "Wane", "Nocturnal Hollow", "Fractured Echo", "Endless Chasm", "Voidwalk", "Eroded Memories",
			"Forsaken Sanctuary", "Vortex of Silence", "Mortal Coil", "Spectral Divide", "Haunting Expanse", "Tenebrous Labyrinth", "Corroded Chambers", "Bane's Descent", "Dread Core", "Lost Purgatory",
			"Umbral Stretch", "Grave's Whisper", "Malignant Nexus", "Fallen Dominion", "Ephemeral Passage", "Netherbound", "Gloom's Heart", "Stygian Abyss", "Ruination", "Cursed Gallery",
			"Eclipsed Reality", "Doom's Cradle", "Mourning Depths", "Harbinger's Hold", "Catastrophic Crevasse", "Blighted Reliquary", "Shadow's Embrace", "Sorrow's Enclave", "Dusk's Demise", "Ghastly Gorge",
			"Inferno's Mouth", "Vice's Grasp", "Bleak Bastion", "Silent Sunder", "Dark Nexus", "Obsidian Oubliette", "Ravaged Resonance", "Dreadnaught's Depth", "Twilight Tomb", "Void's Verge",
			"Bane's Breach", "Ethereal Edge", "Fathomless", "Grim Gallery", "Haunt's Halls", "Mist's Murk", "Descent into Darkness", "Petrified Path", "Eerie Expanse", "Lurk's Labyrinth",
			"Perdition's Pits", "Spectral Spire", "Torrid Tunnels", "Wraith's Wake", "Desolate Divide", "Graveyard Grotto", "Hollow's Heart", "Sable Sorrow", "Twisted Terrain", "Umbral Underbelly",
			"Void's Vestige", "Wither's Way", "Crypt's Crux", "Eldritch Elevations", "Fallen's Folly", "Gloom's Gulch", "Hell's Hinge", "Infernal Interstice", "Jagged Jaws", "Kiln of Khaos",
			"Lament's Landing", "Maw's Murmur", "Necrotic Niche", "Oblivion's Overture", "Phantom's Phalanx", "Quarry of Quietude", "Riven Realm", "Shadow's Shroud", "Turbid Trench", "Unraveling Umbras",
			"Vexed Vistas", "Whisper's Wane", "Xenolith Expanse", "Yawning Yoke", "Zenith of Zero"
		};

		public static string[] VerbsPresentParticiple = new string[40]
		{
			"Withering", "Crumbling", "Decaying", "Floundering", "Suffering", "Languishing", "Deteriorating", "Collapsing", "Disintegrating", "Perishing",
			"Degenerating", "Fading", "Declining", "Eroding", "Wasting", "Dissipating", "Wilting", "Corroding", "Regressing", "Despairing",
			"Weakening", "Struggling", "Depleting", "Atrophying", "Wrecking", "Diminishing", "Bleeding", "Slipping", "Moldering", "Drowning",
			"Fraying", "Succumbing", "Breaking", "Sinking", "Fading", "Ravaging", "Dissolving", "Caving", "Fumbling", "Draining"
		};

		public static string[] GtfoEnemies = new string[16]
		{
			"Striker", "Shooter", "Charger", "Shadow", "Giant Striker", "Giant Shooter", "Giant Charger", "Shadow Giant", "Hybrid", "Scout",
			"Charger Scout", "Shadow Scout", "Tank", "Immortal", "Mother", "P-Mother"
		};

		public static string[] SeedWords = new string[1000]
		{
			"apple", "banana", "cherry", "dog", "cat", "bird", "fish", "house", "chair", "table",
			"book", "pen", "hat", "car", "bus", "shoe", "sock", "bag", "tree", "sun",
			"moon", "star", "water", "river", "lake", "ocean", "beach", "sand", "wind", "rain",
			"snow", "cloud", "storm", "grass", "leaf", "flower", "rose", "tulip", "daisy", "lily",
			"bird", "eagle", "hawk", "dove", "raven", "paper", "pencil", "eraser", "ruler", "desk",
			"phone", "clock", "watch", "lamp", "light", "music", "song", "dance", "play", "game",
			"ball", "bat", "glove", "goal", "run", "walk", "sit", "stand", "jump", "dance",
			"sing", "laugh", "cry", "smile", "frown", "speak", "listen", "read", "write", "draw",
			"paint", "color", "print", "ship", "boat", "plane", "train", "car", "bus", "bike",
			"bell", "ring", "gift", "card", "party", "cake", "pie", "ice", "cream", "sugar",
			"salt", "spice", "bread", "meat", "egg", "milk", "cheese", "pasta", "rice", "soup",
			"salad", "fruit", "grape", "orange", "lemon", "lime", "melon", "berry", "nut", "date",
			"honey", "butter", "jam", "jelly", "candy", "choco", "cookie", "muffin", "donut", "coffee",
			"tea", "juice", "soda", "water", "beer", "wine", "drink", "glass", "plate", "bowl",
			"spoon", "fork", "knife", "napkin", "towel", "sheet", "blanket", "pillow", "bed", "sofa",
			"chair", "bench", "floor", "wall", "door", "window", "roof", "chimney", "fence", "yard",
			"garden", "field", "farm", "barn", "stable", "horse", "cow", "pig", "sheep", "goat",
			"chicken", "turkey", "duck", "pond", "pool", "park", "zoo", "forest", "hill", "mountain",
			"valley", "desert", "island", "beach", "wave", "tide", "coral", "fish", "whale", "shark",
			"dolphin", "seal", "crab", "lobster", "squid", "octopus", "snail", "turtle", "lizard", "snake",
			"frog", "spider", "ant", "bee", "bug", "fly", "worm", "rat", "mouse", "rabbit",
			"bear", "tiger", "lion", "leopard", "panther", "wolf", "fox", "deer", "moose", "elk",
			"beaver", "otter", "raccoon", "skunk", "bat", "owl", "city", "town", "village", "road",
			"street", "alley", "avenue", "highway", "bridge", "tunnel", "port", "harbor", "station", "hotel",
			"motel", "inn", "bank", "market", "mall", "store", "shop", "office", "factory", "school",
			"church", "temple", "mosque", "museum", "library", "zoo", "park", "garden", "circus", "theater",
			"cinema", "cafe", "bar", "club", "gym", "spa", "salon", "hospital", "clinic", "prison",
			"police", "army", "navy", "air", "fire", "metal", "wood", "cloth", "silk", "wool",
			"cotton", "paper", "stone", "rock", "brick", "clay", "glass", "gold", "silver", "bronze",
			"steel", "iron", "copper", "lead", "tin", "zinc", "nickel", "chrome", "plastic", "rubber",
			"leather", "fur", "feather", "wool", "rope", "wire", "chain", "nail", "screw", "bolt",
			"nut", "wheel", "tire", "pedal", "gear", "brake", "seat", "belt", "hat", "cap",
			"helmet", "scarf", "glove", "sock", "shoe", "boot", "sandal", "shirt", "blouse", "dress",
			"skirt", "pants", "jeans", "suit", "tie", "jacket", "coat", "sweater", "vest", "cape",
			"robe", "pajama", "underwear", "bra", "panty", "diaper", "purse", "wallet", "bag", "suitcase",
			"box", "can", "jar", "bottle", "jug", "cup", "mug", "plate", "bowl", "spoon",
			"fork", "knife", "chopstick", "pin", "needle", "thread", "button", "zipper", "scissors", "razor",
			"comb", "brush", "mirror", "towel", "soap", "shampoo", "lotion", "perfume", "makeup", "lipstick",
			"eyeshadow", "mascara", "nailpolish", "ring", "earring", "necklace", "bracelet", "watch", "clock", "radio",
			"phone", "camera", "computer", "printer", "scanner", "TV", "DVD", "CD", "disk", "tape",
			"book", "magazine", "newspaper", "letter", "card", "envelope", "stamp", "pen", "pencil", "marker",
			"crayon", "paint", "brush", "easel", "canvas", "paper", "notebook", "binder", "folder", "file",
			"clip", "staple", "glue", "tape", "ruler", "calculator", "lamp", "bulb", "plug", "wire",
			"battery", "charger", "remote", "headset", "speaker", "microphone", "keyboard", "mouse", "screen", "monitor",
			"drive", "router", "modem", "antenna", "satellite", "rocket", "plane", "helicopter", "drone", "ship",
			"boat", "car", "truck", "bus", "train", "tram", "bike", "scooter", "skateboard", "rollerblade",
			"sled", "ski", "surfboard", "parachute", "tent", "sleepingbag", "backpack", "flashlight", "lantern", "match",
			"lighter", "stove", "oven", "microwave", "refrigerator", "freezer", "dishwasher", "washingmachine", "dryer", "vacuum",
			"broom", "mop", "bucket", "bin", "trash", "recycle", "leaf", "grass", "flower", "tree",
			"bush", "vine", "mushroom", "fruit", "vegetable", "grain", "bean", "nut", "meat", "poultry",
			"fish", "seafood", "dairy", "egg", "cheese", "butter", "oil", "sugar", "salt", "spice",
			"tea", "coffee", "cocoa", "water", "juice", "soda", "wine", "beer", "liquor", "cocktail",
			"soup", "salad", "sandwich", "pizza", "pasta", "rice", "bread", "cake", "pie", "cookie",
			"candy", "icecream", "jelly", "jam", "honey", "syrup", "vinegar", "sauce", "ketchup", "mustard",
			"mayo", "pepper", "chili", "garlic", "onion", "potato", "carrot", "bean", "pea", "corn",
			"cucumber", "lettuce", "tomato", "pepper", "broccoli", "spinach", "mushroom", "olive", "pickle", "apple",
			"banana", "orange", "berry", "grape", "lemon", "lime", "melon", "mango", "papaya", "pineapple",
			"coconut", "cherry", "plum", "peach", "apricot", "nut", "almond", "peanut", "walnut", "chestnut",
			"hazelnut", "meat", "pork", "beef", "lamb", "chicken", "turkey", "duck", "fish", "salmon",
			"tuna", "shrimp", "crab", "lobster", "oyster", "clam", "mussel", "squid", "octopus", "egg",
			"milk", "cheese", "yogurt", "butter", "cream", "icecream", "chocolate", "candy", "cookie", "cake",
			"pie", "muffin", "donut", "bread", "toast", "bagel", "roll", "croissant", "pancake", "waffle",
			"cereal", "oatmeal", "rice", "pasta", "noodle", "sushi", "pizza", "burger", "hotdog", "sandwich",
			"wrap", "taco", "burrito", "salad", "soup", "stew", "chili", "curry", "sauce", "gravy",
			"dressing", "ketchup", "mustard", "mayo", "relish", "pickles", "olives", "jam", "jelly", "honey",
			"syrup", "butter", "oil", "vinegar", "salt", "pepper", "spice", "herb", "garlic", "onion",
			"tomato", "potato", "carrot", "celery", "lettuce", "cabbage", "spinach", "broccoli", "pepper", "bean",
			"pea", "corn", "cucumber", "zucchini", "squash", "pumpkin", "eggplant", "mushroom", "olive", "apple",
			"banana", "orange", "berry", "grape", "lemon", "lime", "melon", "mango", "papaya", "pineapple",
			"coconut", "cherry", "plum", "peach", "apricot", "berry", "kiwi", "date", "fig", "raisin",
			"nut", "almond", "peanut", "walnut", "chestnut", "hazelnut", "cashew", "pecan", "macadamia", "meat",
			"pork", "beef", "lamb", "chicken", "turkey", "duck", "fish", "salmon", "tuna", "shrimp",
			"crab", "lobster", "oyster", "clam", "mussel", "squid", "octopus", "caviar", "egg", "milk",
			"cheese", "yogurt", "butter", "cream", "icecream", "chocolate", "candy", "cookie", "cake", "pie",
			"muffin", "donut", "bread", "toast", "bagel", "roll", "croissant", "pancake", "waffle", "cereal",
			"oatmeal", "rice", "pasta", "noodle", "sushi", "pizza", "burger", "hotdog", "sandwich", "wrap",
			"taco", "burrito", "salad", "soup", "stew", "chili", "curry", "sauce", "gravy", "dressing",
			"ketchup", "mustard", "mayo", "relish", "pickles", "olives", "jam", "jelly", "honey", "syrup",
			"butter", "oil", "vinegar", "salt", "pepper", "spice", "herb", "garlic", "onion", "tomato",
			"potato", "carrot", "celery", "lettuce", "cabbage", "spinach", "broccoli", "pepper", "bean", "pea",
			"corn", "cucumber", "zucchini", "squash", "pumpkin", "eggplant", "mushroom", "olive", "apple", "banana",
			"orange", "berry", "grape", "lemon", "lime", "melon", "mango", "papaya", "pineapple", "coconut",
			"cherry", "plum", "peach", "apricot", "berry", "kiwi", "date", "fig", "raisin", "nut",
			"almond", "peanut", "walnut", "chestnut", "hazelnut", "cashew", "pecan", "macadamia", "meat", "pork",
			"beef", "lamb", "chicken", "turkey", "duck", "fish", "salmon", "tuna", "shrimp", "crab",
			"lobster", "oyster", "clam", "mussel", "squid", "octopus", "caviar", "egg", "milk", "cheese",
			"yogurt", "butter", "cream", "icecream", "chocolate", "candy", "cookie", "cake", "pie", "muffin",
			"donut", "bread", "toast", "bagel", "roll", "croissant", "pancake", "waffle", "cereal", "oatmeal",
			"rice", "pasta", "noodle", "sushi", "pizza", "burger", "hotdog", "sandwich", "wrap", "taco",
			"burrito", "salad", "soup", "stew", "chili", "curry", "sauce", "gravy", "dressing", "ketchup",
			"mustard", "mayo", "relish", "pickles", "olives", "jam", "jelly", "honey", "syrup", "butter",
			"oil", "vinegar", "salt", "pepper", "spice", "herb", "garlic", "onion", "tomato", "potato",
			"carrot", "celery", "lettuce", "cabbage", "spinach", "broccoli", "pepper", "bean", "pea", "corn",
			"cucumber", "zucchini", "squash", "pumpkin", "eggplant", "mushroom", "olive", "apple", "banana", "orange",
			"berry", "grape", "lemon", "lime", "melon", "mango", "papaya", "pineapple", "coconut", "cherry",
			"plum", "peach", "apricot", "berry", "kiwi", "date", "fig", "raisin", "nut", "almond",
			"peanut", "walnut", "chestnut", "hazelnut", "cashew", "pecan", "macadamia", "meat", "pork", "beef",
			"lamb", "chicken", "turkey", "duck", "fish", "salmon", "tuna", "shrimp", "crab", "lobster",
			"oyster", "clam", "mussel", "squid", "octopus", "caviar", "egg", "milk", "cheese", "yogurt",
			"butter", "cream", "icecream", "chocolate", "candy", "cookie", "cake", "pie", "muffin", "donut"
		};
	}
}
namespace AutogenRundown.DataBlocks
{
	public enum Height
	{
		LowMidHigh,
		OnlyLow,
		OnlyHigh,
		OnlyMid,
		LowMid,
		MidHigh,
		LowHigh,
		Ascending,
		Descending,
		Unchanged
	}
	public class Altitude
	{
		public Height AllowedZoneAltitude { get; set; } = Height.OnlyMid;


		public double ChanceToChange { get; set; } = 0.5;

	}
	public record BigPickupDistribution : DataBlock
	{
		public uint SpawnsPerZone { get; set; }

		public List<ItemSpawn> SpawnData { get; set; } = new List<ItemSpawn>();


		public static BigPickupDistribution FogTurbine = new BigPickupDistribution
		{
			SpawnsPerZone = 1u,
			SpawnData = 
			{
				new ItemSpawn
				{
					Item = Item.FogTurbine
				}
			}
		};

		public new static void SaveStatic()
		{
			Bins.BigPickupDistributions.AddBlock(FogTurbine);
		}

		[CompilerGenerated]
		protected BigPickupDistribution(BigPickupDistribution original)
			: base(original)
		{
			SpawnsPerZone = original.SpawnsPerZone;
			SpawnData = original.SpawnData;
		}

		public BigPickupDistribution()
		{
		}
	}
	public static class Bins
	{
		public static BlocksBin<BigPickupDistribution> BigPickupDistributions { get; private set; } = new BlocksBin<BigPickupDistribution>();


		public static BlocksBin<ChainedPuzzle> ChainedPuzzles { get; private set; } = new BlocksBin<ChainedPuzzle>();


		public static BlocksBin<ConsumableDistribution> ConsumableDistributions { get; private set; } = new BlocksBin<ConsumableDistribution>();


		public static BlocksBin<EnemyGroup> EnemyGroups { get; private set; } = new BlocksBin<EnemyGroup>();


		public static BlocksBin<EnemyPopulation> EnemyPopulations { get; private set; } = new BlocksBin<EnemyPopulation>();


		public static BlocksBin<Fog> Fogs { get; private set; } = new BlocksBin<Fog>();


		public static BlocksBin<LevelLayout> LevelLayouts { get; private set; } = new BlocksBin<LevelLayout>();


		public static BlocksBin<Rundown> Rundowns { get; private set; } = new BlocksBin<Rundown>();


		public static BlocksBin<WardenObjective> WardenObjectives { get; private set; } = new BlocksBin<WardenObjective>();


		public static BlocksBin<WavePopulation> WavePopulations { get; private set; } = new BlocksBin<WavePopulation>();


		public static BlocksBin<WaveSettings> WaveSettings { get; private set; } = new BlocksBin<WaveSettings>();


		public static void Setup()
		{
			EnemyGroup.Setup();
			EnemyPopulation.Setup();
			WavePopulation.Setup();
			AutogenRundown.DataBlocks.Alarms.WaveSettings.Setup();
			BigPickupDistribution.SaveStatic();
			ChainedPuzzle.SaveStatic();
			ConsumableDistribution.SaveStatic();
			EnemyGroup.SaveStatic();
			EnemyPopulation.SaveStatic();
			Fog.SaveStatic();
			DataBlock.SaveStatic();
			DataBlock.SaveStatic();
			DataBlock.SaveStatic();
			WavePopulation.SaveStatic();
			AutogenRundown.DataBlocks.Alarms.WaveSettings.SaveStatic();
		}

		public static void Save()
		{
			BigPickupDistributions.Save("BigPickupDistribution");
			ChainedPuzzles.Save("ChainedPuzzle");
			ConsumableDistributions.Save("ConsumableDistribution");
			EnemyGroups.Save("EnemyGroup");
			EnemyPopulations.Save("EnemyPopulation");
			Fogs.Save("FogSettings");
			LevelLayouts.Save("LevelLayout");
			Rundowns.Save("Rundown");
			WardenObjectives.Save("WardenObjective");
			WavePopulations.Save("SurvivalWavePopulation");
			WaveSettings.Save("SurvivalWaveSettings");
		}
	}
	public class BlocksBin<T> where T : DataBlock
	{
		private HashSet<uint> persistentIds = new HashSet<uint>();

		public List<JObject> Headers { get; set; } = new List<JObject>();


		public List<T> Blocks { get; set; } = new List<T>();


		[JsonProperty("LastPersistentID")]
		public uint LastPersistentId { get; set; }

		public void AddBlock(T? block)
		{
			if (block != null && !persistentIds.Contains(block.PersistentId) && block.PersistentId != 0)
			{
				Blocks.Add(block);
				persistentIds.Add(block.PersistentId);
				LastPersistentId = Math.Max(LastPersistentId, block.PersistentId);
			}
		}

		public T? Find(uint id)
		{
			return Blocks.Find((T b) => b.PersistentId == id);
		}

		public void Save(string name)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			JsonSerializer val = new JsonSerializer();
			val.Formatting = (Formatting)1;
			int revision = CellBuildData.GetRevision();
			string text = Path.Combine(Paths.BepInExRootPath, "GameData", $"{revision}");
			string path = Path.Combine(text, "GameData_" + name + "DataBlock_bin.json");
			Directory.CreateDirectory(text);
			using StreamWriter streamWriter = new StreamWriter(path);
			JsonWriter val2 = (JsonWriter)new JsonTextWriter((TextWriter)streamWriter);
			try
			{
				val.Serialize(val2, (object)this);
				streamWriter.Flush();
			}
			finally
			{
				((IDisposable)val2)?.Dispose();
			}
		}
	}
	public class BulkheadDoorPlacementData
	{
		public int ZoneIndex { get; set; }

		public ZonePlacementWeights PlacementWeights { get; set; } = new ZonePlacementWeights();


		public int AreaSeedOffset { get; set; }

		public int MarkerSeedOffset { get; set; }
	}
	public record Color
	{
		[JsonProperty("a")]
		public double Alpha { get; set; }

		[JsonProperty("r")]
		public double Red { get; set; }

		[JsonProperty("g")]
		public double Green { get; set; }

		[JsonProperty("b")]
		public double Blue { get; set; }

		public static Color MenuVisuals = new Color
		{
			Alpha = 1.0,
			Red = 0.4509804,
			Green = 0.7490196,
			Blue = 0.858823538
		};

		public static Color White = new Color
		{
			Red = 1.0,
			Green = 1.0,
			Blue = 1.0,
			Alpha = 1.0
		};

		[CompilerGenerated]
		protected Color(Color original)
		{
			Alpha = original.Alpha;
			Red = original.Red;
			Green = original.Green;
			Blue = original.Blue;
		}

		public Color()
		{
		}
	}
	public record ConsumableDistribution : DataBlock
	{
		public uint SpawnsPerZone { get; set; } = 5u;


		public double ChanceToSpawnInResourceContainer { get; set; } = 0.9;


		public List<ItemSpawn> SpawnData { get; set; } = new List<ItemSpawn>();


		public static ConsumableDistribution Baseline = new ConsumableDistribution
		{
			SpawnsPerZone = 6u,
			SpawnData = Collections.Flatten<ItemSpawn>(ItemSpawn.GlowSticks(8.0), new List<ItemSpawn>
			{
				new ItemSpawn
				{
					Item = Item.LockMelter,
					Weight = 8.0
				},
				new ItemSpawn
				{
					Item = Item.CfoamGrenade,
					Weight = 1.0
				},
				new ItemSpawn
				{
					Item = Item.ExplosiveTripmine,
					Weight = 1.0
				}
			})
		};

		public static ConsumableDistribution Baseline_FogRepellers = new ConsumableDistribution
		{
			SpawnsPerZone = 8u,
			SpawnData = Collections.Flatten<ItemSpawn>(ItemSpawn.GlowSticks(3.0), new List<ItemSpawn>
			{
				new ItemSpawn
				{
					Item = Item.LockMelter,
					Weight = 1.0
				},
				new ItemSpawn
				{
					Item = Item.FogRepeller,
					Weight = 4.0
				}
			})
		};

		public new static void SaveStatic()
		{
			Bins.ConsumableDistributions.AddBlock(Baseline);
			Bins.ConsumableDistributions.AddBlock(Baseline_FogRepellers);
		}

		[CompilerGenerated]
		protected ConsumableDistribution(ConsumableDistribution original)
			: base(original)
		{
			SpawnsPerZone = original.SpawnsPerZone;
			ChanceToSpawnInResourceContainer = original.ChanceToSpawnInResourceContainer;
			SpawnData = original.SpawnData;
		}

		public ConsumableDistribution()
		{
		}
	}
	public enum CoverageSize
	{
		Nano = 25,
		Tiny = 35,
		Small = 50,
		Medium = 75,
		Large = 125,
		Huge = 200
	}
	public class CoverageMinMax
	{
		private static List<double> Sizes = new List<double> { 25.0, 35.0, 50.0, 75.0, 125.0, 200.0 };

		private Vector2 vec = new Vector2
		{
			X = 0f,
			Y = 0f
		};

		public static CoverageMinMax Nano = new CoverageMinMax
		{
			Min = 25.0,
			Max = 25.0
		};

		public static CoverageMinMax Tiny = new CoverageMinMax
		{
			Min = 35.0,
			Max = 35.0
		};

		public static CoverageMinMax Small = new CoverageMinMax
		{
			Min = 50.0,
			Max = 50.0
		};

		public static CoverageMinMax Medium = new CoverageMinMax
		{
			Min = 75.0,
			Max = 75.0
		};

		public static CoverageMinMax Large = new CoverageMinMax
		{
			Min = 125.0,
			Max = 125.0
		};

		public static CoverageMinMax Huge = new CoverageMinMax
		{
			Min = 200.0,
			Max = 200.0
		};

		private static List<double> NormalSizes = new List<double>
		{
			10.0, 15.0, 20.0, 20.0, 25.0, 25.0, 30.0, 30.0, 35.0, 35.0,
			40.0, 40.0, 45.0, 45.0, 50.0
		};

		[JsonProperty("x")]
		public double Min
		{
			get
			{
				return vec.X;
			}
			set
			{
				vec.X = (float)value;
			}
		}

		[JsonProperty("y")]
		public double Max
		{
			get
			{
				return vec.Y;
			}
			set
			{
				vec.Y = (float)value;
			}
		}

		[JsonProperty("normalized")]
		public JObject Normalized
		{
			get
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Unknown result type (might be due to invalid IL or missing references)
				//IL_0070: Expected O, but got Unknown
				Vector2 vector = Vector2.Normalize(vec);
				return new JObject
				{
					["x"] = JToken.op_Implicit(vector.X),
					["y"] = JToken.op_Implicit(vector.Y),
					["magnitude"] = JToken.op_Implicit(1.0),
					["sqrMagnitude"] = JToken.op_Implicit(1.0)
				};
			}
		}

		[JsonProperty("magnitude")]
		public double Magnitude => vec.Length();

		[JsonProperty("sqrMagnitude")]
		public double SqrMagnitude => vec.LengthSquared();

		public CoverageMinMax()
		{
		}

		public CoverageMinMax(double value)
		{
			Min = value;
			Max = value;
		}

		public static CoverageMinMax GenCoverage()
		{
			return new CoverageMinMax
			{
				Min = Generator.Pick(Sizes),
				Max = Generator.Pick(Sizes)
			};
		}

		public static CoverageMinMax GenNormalSize()
		{
			double num = Generator.Pick(NormalSizes);
			return new CoverageMinMax
			{
				Min = num,
				Max = num
			};
		}

		public static CoverageMinMax GenStartZoneSize()
		{
			double num = Generator.Pick(new List<double> { 25.0, 30.0, 35.0, 50.0 });
			return new CoverageMinMax
			{
				Min = num,
				Max = num + 20.0
			};
		}

		public static CoverageMinMax GenSize(int zoneIndex)
		{
			if (zoneIndex != 0)
			{
				return GenNormalSize();
			}
			return GenStartZoneSize();
		}
	}
	public record DataBlock
	{
		[JsonProperty("persistentID")]
		public uint PersistentId { get; set; }

		[JsonProperty("name")]
		public string Name { get; set; }

		[JsonProperty("internalEnabled")]
		public bool Enabled { get; set; } = true;


		[JsonIgnore]
		public string? Filename => $"{PersistentId}__{Name?.Replace(' ', '_')}";

		public DataBlock(uint? id = null)
		{
			PersistentId = id ?? Generator.GetPersistentId();
			Name = PersistentId.ToString();
		}

		public void Save()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			JsonSerializer val = new JsonSerializer();
			val.Formatting = (Formatting)1;
			int revision = CellBuildData.GetRevision();
			string text = Path.Combine(Paths.BepInExRootPath, "GameData", $"{revision}", "Custom");
			string path = Path.Combine(text, "GameData__" + Filename + ".json");
			Directory.CreateDirectory(text);
			using StreamWriter streamWriter = new StreamWriter(path);
			JsonWriter val2 = (JsonWriter)new JsonTextWriter((TextWriter)streamWriter);
			try
			{
				val.Serialize(val2, (object)this);
			}
			finally
			{
				((IDisposable)val2)?.Dispose();
			}
		}

		public static void Setup()
		{
		}

		public static void SaveStatic()
		{
		}
	}
	public enum EnemyRoleDifficulty : uint
	{
		Easy,
		Medium,
		Hard,
		MiniBoss,
		Boss,
		Tank,
		Biss,
		Buss
	}
	public enum EnemyZoneDistribution
	{
		None,
		ForceOne,
		RelValue
	}
	public record EnemySpawningData
	{
		public EnemyGroupType GroupType { get; set; }

		public uint Difficulty { get; set; }

		public EnemyZoneDistribution Distribution { get; set; } = EnemyZoneDistribution.RelValue;


		[JsonIgnore]
		public int Points { get; set; } = 25;


		public double DistributionValue => (double)Points / (double)POPULATION_PER_ZONE;

		public static int POPULATION_PER_ZONE = 25;

		public static EnemySpawningData TierA = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 256u
		};

		public static EnemySpawningData TierB = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 512u
		};

		public static EnemySpawningData TierC = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 1024u
		};

		public static EnemySpawningData TierD = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 2048u
		};

		public static EnemySpawningData TierE = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 4096u
		};

		public static EnemySpawningData Striker = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 24u
		};

		public static EnemySpawningData Shooter = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 26u
		};

		public static EnemySpawningData Scout = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Scout,
			Difficulty = 0u
		};

		public static EnemySpawningData ScoutCharger = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Scout,
			Difficulty = 3u
		};

		public static EnemySpawningData ScoutShadow = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Scout,
			Difficulty = 4u
		};

		public static EnemySpawningData Mother = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 36u
		};

		public static EnemySpawningData PMother = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 37u
		};

		public static EnemySpawningData Baby = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 38u
		};

		public static EnemySpawningData Tank = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 29u
		};

		[CompilerGenerated]
		protected EnemySpawningData(EnemySpawningData original)
		{
			GroupType = original.GroupType;
			Difficulty = original.Difficulty;
			Distribution = original.Distribution;
			Points = original.Points;
		}

		public EnemySpawningData()
		{
		}
	}
	public enum Complex
	{
		Mining = 1,
		Tech = 3,
		Service = 27
	}
	public enum SubComplex
	{
		DigSite = 0,
		Refinery = 1,
		Storage = 2,
		DataCenter = 3,
		Lab = 4,
		Floodways = 6,
		Gardens = 11,
		All = 5
	}
	public record Fog : DataBlock
	{
		[JsonIgnore]
		public List<Height> FogLevels { get; set; } = new List<Height>();


		[JsonIgnore]
		public List<Height> NoFogLevels { get; set; } = new List<Height>
		{
			Height.LowMidHigh,
			Height.OnlyLow,
			Height.OnlyHigh,
			Height.OnlyMid,
			Height.LowMid,
			Height.MidHigh,
			Height.LowHigh
		};


		public Color FogColor { get; set; } = Color.White;


		public double FogDensity { get; set; } = 0.02;


		[Obsolete("Unused")]
		public double FogAmbience { get; set; } = 0.0001;


		public Vector3 DensityNoiseDirection { get; set; } = new Vector3
		{
			Y = 1.0
		};


		public double DensityNoiseSpeed { get; set; } = 0.055;


		public double DensityNoiseScale { get; set; } = 0.045;


		public double DensityHeightAltitude { get; set; } = 5.0;


		public double DensityHeightRange { get; set; } = 2.5;


		public double DensityHeightMaxBoost { get; set; } = 0.00075;


		public double Infection { get; set; }

		public static double DENSITY_CLEAR = 8E-05;

		public static double DENSITY_LOW = 0.0007;

		public static double DENSITY_MED = 0.005;

		public static double DENSITY_HIGH = 0.015;

		public static double DENSITY_FULL = 0.045;

		public static double HEIGHT_LOW = -4.0;

		public static double HEIGHT_MED = 0.0;

		public static double HEIGHT_HIGH = 4.0;

		public static Fog None = new Fog
		{
			PersistentId = 0u
		};

		public static Fog DefaultFog = new Fog
		{
			Name = "Fog_DefaultFog",
			FogColor = new Color
			{
				Red = 0.5235849,
				Green = 0.682390034,
				Blue = 1.0,
				Alpha = 0.0
			},
			FogDensity = 0.0004,
			DensityNoiseDirection = new Vector3
			{
				X = 1.0,
				Y = 1.0,
				Z = 1.0
			},
			DensityNoiseSpeed = 0.0372,
			DensityNoiseScale = 0.08,
			DensityHeightAltitude = -5.2,
			DensityHeightRange = 0.6,
			DensityHeightMaxBoost = 0.002,
			Infection = 0.0
		};

		public static Fog LowFog = new Fog
		{
			Name = "Fog_Low",
			FogColor = new Color
			{
				Red = 0.4,
				Green = 0.68,
				Blue = 1.0,
				Alpha = 0.0
			},
			DensityHeightAltitude = HEIGHT_LOW,
			DensityHeightMaxBoost = DENSITY_FULL,
			FogDensity = DENSITY_LOW,
			FogLevels = { Height.OnlyLow },
			NoFogLevels = 
			{
				Height.OnlyMid,
				Height.OnlyHigh,
				Height.MidHigh
			}
		};

		public static Fog LowMidFog = new Fog
		{
			Name = "Fog_LowMid",
			FogColor = new Color
			{
				Red = 0.4,
				Green = 0.68,
				Blue = 1.0,
				Alpha = 0.0
			},
			DensityHeightAltitude = HEIGHT_MED,
			DensityHeightMaxBoost = DENSITY_FULL,
			FogDensity = DENSITY_LOW,
			FogLevels = 
			{
				Height.OnlyLow,
				Height.OnlyMid,
				Height.LowMid
			},
			NoFogLevels = { Height.OnlyHigh }
		};

		public static Fog FullFog = new Fog
		{
			Name = "Fog_Full",
			DensityHeightAltitude = 4.0,
			FogLevels = 
			{
				Height.LowMidHigh,
				Height.OnlyLow,
				Height.OnlyMid,
				Height.OnlyHigh,
				Height.LowMid,
				Height.MidHigh,
				Height.LowHigh
			}
		};

		public static Fog FullFog_Infectious = FullFog with
		{
			Name = "Fog_FullInfectious",
			PersistentId = Generator.GetPersistentId(),
			Infection = 0.03
		};

		public new static void SaveStatic()
		{
			Bins.Fogs.AddBlock(DefaultFog);
			Bins.Fogs.AddBlock(LowFog);
			Bins.Fogs.AddBlock(FullFog);
			Bins.Fogs.AddBlock(FullFog_Infectious);
		}

		[CompilerGenerated]
		protected Fog(Fog original)
			: base(original)
		{
			FogLevels = original.FogLevels;
			NoFogLevels = original.NoFogLevels;
			FogColor = original.FogColor;
			FogDensity = original.FogDensity;
			FogAmbience = original.FogAmbience;
			DensityNoiseDirection = original.DensityNoiseDirection;
			DensityNoiseSpeed = original.DensityNoiseSpeed;
			DensityNoiseScale = original.DensityNoiseScale;
			DensityHeightAltitude = original.DensityHeightAltitude;
			DensityHeightRange = original.DensityHeightRange;
			DensityHeightMaxBoost = original.DensityHeightMaxBoost;
			Infection = original.Infection;
		}

		public Fog()
		{
		}
	}
	public class BuildFrom
	{
		public int LayerType { get; set; }

		public int Zone { get; set; }
	}
	public class Level
	{
		public bool Enabled = true;

		public bool IsSinglePlayer;

		public bool SkipLobby;

		public bool PutIconAboveTier;

		public bool DisablePlayerVoicelines;

		public bool ExcludeFromProgression;

		public bool HideOnLocked;

		public bool HasExternalStyle;

		public bool HasStoryStyle;

		public bool UseGearPicker;

		public JArray DimensionDatas = new JArray();

		public int SoundEventOnWarpToReality;

		public JObject Seeds = JObject.FromObject((object)new
		{
			BuildSeed = Generator.Random.Next(2000),
			FunctionMarkerOffset = 1,
			StandardMarkerOffset = 0,
			LightJobSeedOffset = 0
		});

		public JObject VanityItemsDropData = new JObject { ["Groups"] = (JToken)new JArray() };

		public BuildFrom BuildSecondaryFrom = new BuildFrom
		{
			LayerType = 0,
			Zone = 0
		};

		public BuildFrom BuildThirdFrom = new BuildFrom
		{
			LayerType = 0,
			Zone = 0
		};

		[JsonIgnore]
		public string Name { get; set; } = "";


		[JsonIgnore]
		public string Tier { get; set; } = "A";


		[JsonIgnore]
		public int Index { get; set; } = 1;


		[JsonIgnore]
		public int Depth { get; set; } = 1;


		[JsonIgnore]
		public Complex Complex { get; set; } = Generator.Pick(new List<Complex>
		{
			Complex.Mining,
			Complex.Mining,
			Complex.Tech,
			Complex.Tech,
			Complex.Service
		});


		[JsonIgnore]
		public LayoutPlanner Planner { get; set; } = new LayoutPlanner();


		[JsonIgnore]
		public LevelSettings Settings { get; set; }

		[JsonIgnore]
		public int ZoneAliasStart_Main { get; set; }

		[JsonIgnore]
		public int ZoneAliasStart_Extreme { get; set; }

		[JsonIgnore]
		public int ZoneAliasStart_Overload { get; set; }

		[JsonIgnore]
		public Dictionary<Bulkhead, BuildDirector> Director { get; private set; } = new Dictionary<Bulkhead, BuildDirector>();


		[JsonIgnore]
		public BuildDirector MainDirector
		{
			get
			{
				return Director[Bulkhead.Main];
			}
			set
			{
				Director[Bulkhead.Main] = value;
			}
		}

		[JsonIgnore]
		public BuildDirector SecondaryDirector
		{
			get
			{
				return Director[Bulkhead.Extreme];
			}
			set
			{
				Director[Bulkhead.Extreme] = value;
			}
		}

		[JsonIgnore]
		public BuildDirector OverloadDirector
		{
			get
			{
				return Director[Bulkhead.Overload];
			}
			set
			{
				Director[Bulkhead.Overload] = value;
			}
		}

		[JsonIgnore]
		public Dictionary<Bulkhead, ObjectiveLayerData> ObjectiveLayer { get; private set; } = new Dictionary<Bulkhead, ObjectiveLayerData>
		{
			{
				Bulkhead.Main,
				new ObjectiveLayerData()
			},
			{
				Bulkhead.Extreme,
				new ObjectiveLayerData()
			},
			{
				Bulkhead.Overload,
				new ObjectiveLayerData()
			}
		};


		[JsonIgnore]
		public Dictionary<Bulkhead, uint> LayoutRef { get; private set; } = new Dictionary<Bulkhead, uint>
		{
			{
				Bulkhead.Main,
				0u
			},
			{
				Bulkhead.Extreme,
				0u
			},
			{
				Bulkhead.Overload,
				0u
			}
		};


		[JsonIgnore]
		public int MainBulkheadZone { get; set; }

		[JsonIgnore]
		public string Description { get; set; } = "";


		[JsonIgnore]
		public Fog FogSettings { get; set; } = Fog.DefaultFog;


		[JsonIgnore]
		public bool IsTest { get; set; }

		public JObject Descriptive => new JObject
		{
			["Prefix"] = JToken.op_Implicit(IsTest ? "TEST" : Tier),
			["PublicName"] = JToken.op_Implicit(Name),
			["IsExtraExpedition"] = JToken.op_Implicit(false),
			["SkipExpNumberInName"] = JToken.op_Implicit(IsTest),
			["UseCustomMatchmakingTier"] = JToken.op_Implicit(false),
			["CustomMatchmakingTier"] = JToken.op_Implicit(1),
			["ProgressionVisualStyle"] = JToken.op_Implicit(IsTest ? 1 : 0),
			["ExpeditionDepth"] = JToken.op_Implicit(Depth),
			["EstimatedDuration"] = JToken.op_Implicit(930),
			["ExpeditionDescription"] = JToken.op_Implicit(Description),
			["RoleplayedWardenIntel"] = JToken.op_Implicit(1426)
		};

		public JObject Expedition => new JObject
		{
			["ComplexResourceData"] = JToken.op_Implicit((int)Complex),
			["MLSLevelKit"] = JToken.op_Implicit(0),
			["LightSettings"] = JToken.op_Implicit(36),
			["FogSettings"] = JToken.op_Implicit(FogSettings.PersistentId),
			["EnemyPopulation"] = JToken.op_Implicit(1),
			["ExpeditionBalance"] = JToken.op_Implicit(1),
			["ScoutWaveSettings"] = JToken.op_Implicit(3),
			["ScoutWavePopulation"] = JToken.op_Implicit(1),
			["EnvironmentWetness"] = JToken.op_Implicit(0.0),
			["DustColor"] = (JToken)(object)JObject.FromObject((object)new Color
			{
				Alpha = 1.0,
				Red = 0.5,
				Green = 0.5,
				Blue = 0.5
			}),
			["DustTurbulence"] = JToken.op_Implicit(1.0)
		};

		public uint LevelLayoutData
		{
			get
			{
				return LayoutRef[Bulkhead.Main];
			}
			set
			{
				LayoutRef[Bulkhead.Main] = value;
			}
		}

		public ObjectiveLayerData MainLayerData
		{
			get
			{
				return ObjectiveLayer[Bulkhead.Main];
			}
			set
			{
				ObjectiveLayer[Bulkhead.Main] = value;
			}
		}

		public ObjectiveLayerData SecondaryLayerData
		{
			get
			{
				return ObjectiveLayer[Bulkhead.Extreme];
			}
			set
			{
				ObjectiveLayer[Bulkhead.Extreme] = value;
			}
		}

		public bool SecondaryLayerEnabled
		{
			get
			{
				return SecondaryLayout != 0;
			}
			private set
			{
			}
		}

		public uint SecondaryLayout
		{
			get
			{
				return LayoutRef[Bulkhead.Extreme];
			}
			set
			{
				LayoutRef[Bulkhead.Extreme] = value;
			}
		}

		public ObjectiveLayerData ThirdLayerData
		{
			get
			{
				return ObjectiveLayer[Bulkhead.Overload];
			}
			set
			{
				ObjectiveLayer[Bulkhead.Overload] = value;
			}
		}

		public bool ThirdLayerEnabled
		{
			get
			{
				return ThirdLayout != 0;
			}
			private set
			{
			}
		}

		public uint ThirdLayout
		{
			get
			{
				return LayoutRef[Bulkhead.Overload];
			}
			set
			{
				LayoutRef[Bulkhead.Overload] = value;
			}
		}

		[JsonIgnore]
		public double StartingInfection { get; set; }

		[JsonIgnore]
		public double StartingHealth { get; set; } = 1.0;


		[JsonIgnore]
		public double StartingMainAmmo { get; set; } = 1.0;


		[JsonIgnore]
		public double StartingSpecialAmmo { get; set; } = 1.0;


		[JsonIgnore]
		public double StartingTool { get; set; } = 1.0;


		public JObject SpecialOverrideData => new JObject
		{
			["WeakResourceContainerWithPackChanceForLocked"] = JToken.op_Implicit(-1.0),
			["InfectionLevelAtExpeditionStart"] = JToken.op_Implicit(StartingInfection),
			["HealthLevelAtExpeditionStart"] = JToken.op_Implicit(StartingHealth),
			["StandardAmmoAtExpeditionStart"] = JToken.op_Implicit(StartingMainAmmo),
			["SpecialAmmoAtExpeditionStart"] = JToken.op_Implicit(StartingSpecialAmmo),
			["ToolAmmoAtExpeditionStart"] = JToken.op_Implicit(StartingTool)
		};

		public int GetZoneAliasStart(Bulkhead bulkhead)
		{
			return bulkhead switch
			{
				Bulkhead.Main => ZoneAliasStart_Main, 
				Bulkhead.Extreme => ZoneAliasStart_Extreme, 
				Bulkhead.Overload => ZoneAliasStart_Overload, 
				_ => 0, 
			};
		}

		private void GenerateDepth()
		{
			switch (Tier)
			{
			case "A":
				Depth = Generator.Random.Next(420, 650);
				break;
			case "B":
				Depth = Generator.Random.Next(600, 850);
				break;
			case "C":
				Depth = Generator.Random.Next(800, 1000);
				break;
			case "D":
				Depth = Generator.Random.Next(900, 1100);
				break;
			case "E":
				Depth = Generator.Random.Next(950, 1500);
				break;
			}
		}

		private void GenerateZoneAliasStarts()
		{
			object collection = Tier switch
			{
				"B" => new List<(int, int)>
				{
					(50, 170),
					(200, 275),
					(300, 450)
				}, 
				"C" => new List<(int, int)>
				{
					(200, 275),
					(300, 475),
					(500, 600)
				}, 
				"D" => new List<(int, int)>
				{
					(300, 475),
					(500, 680),
					(700, 850)
				}, 
				"E" => new List<(int, int)>
				{
					(450, 570),
					(600, 750),
					(790, 950)
				}, 
				_ => new List<(int, int)>
				{
					(5, 70),
					(95, 135),
					(160, 200)
				}, 
			};
			(int, int) tuple = Generator.Draw((ICollection<(int, int)>)collection);
			int item = tuple.Item1;
			int item2 = tuple.Item2;
			ZoneAliasStart_Main = Generator.Random.Next(item, item2);
			(int, int) tuple2 = Generator.Draw((ICollection<(int, int)>)collection);
			item = tuple2.Item1;
			item2 = tuple2.Item2;
			ZoneAliasStart_Extreme = Generator.Random.Next(item, item2);
			(int, int) tuple3 = Generator.Draw((ICollection<(int, int)>)collection);
			item = tuple3.Item1;
			item2 = tuple3.Item2;
			ZoneAliasStart_Overload = Generator.Random.Next(item, item2);
		}

		public ObjectiveLayerData GetObjectiveLayerData(Bulkhead variant)
		{
			return variant switch
			{
				Bulkhead.Main => MainLayerData, 
				Bulkhead.Extreme => SecondaryLayerData, 
				Bulkhead.Overload => ThirdLayerData, 
				_ => MainLayerData, 
			};
		}

		public WardenObjective? GetObjective(Bulkhead variant)
		{
			return variant switch
			{
				Bulkhead.Main => Bins.WardenObjectives.Find(MainLayerData.ObjectiveData.DataBlockId), 
				Bulkhead.Extreme => Bins.WardenObjectives.Find(SecondaryLayerData.ObjectiveData.DataBlockId), 
				Bulkhead.Overload => Bins.WardenObjectives.Find(ThirdLayerData.ObjectiveData.DataBlockId), 
				Bulkhead.None => throw new NotImplementedException(), 
				Bulkhead.StartingArea => throw new NotImplementedException(), 
				Bulkhead.All => throw new NotImplementedException(), 
				_ => throw new NotImplementedException(), 
			};
		}

		public LevelLayout? GetLevelLayout(Bulkhead variant)
		{
			return variant switch
			{
				Bulkhead.Main => Bins.LevelLayouts.Find(LevelLayoutData), 
				Bulkhead.Extreme => Bins.LevelLayouts.Find(SecondaryLayout), 
				Bulkhead.Overload => Bins.LevelLayouts.Find(ThirdLayout), 
				_ => Bins.LevelLayouts.Find(LevelLayoutData), 
			};
		}

		public void BuildLayout(Bulkhead bulkhead)
		{
			List<WardenObjectiveType> list = new List<WardenObjectiveType>();
			if (Director.ContainsKey(Bulkhead.Main))
			{
				list.Add(Director[Bulkhead.Main].Objective);
			}
			if (Director.ContainsKey(Bulkhead.Extreme))
			{
				list.Add(Director[Bulkhead.Extreme].Objective);
			}
			if (Director.ContainsKey(Bulkhead.Overload))
			{
				list.Add(Director[Bulkhead.Overload].Objective);
			}
			if (!Director.ContainsKey(bulkhead))
			{
				Director[bulkhead] = new BuildDirector
				{
					Bulkhead = bulkhead,
					Complex = Complex,
					Complexity = Complexity.Low,
					Settings = Settings,
					Tier = Tier
				};
				Director[bulkhead].GenObjective(list);
			}
			BuildDirector buildDirector = Director[bulkhead];
			buildDirector.GenPoints();
			WardenObjective wardenObjective = WardenObjective.PreBuild(buildDirector, this);
			LevelLayout levelLayout = LevelLayout.Build(this, buildDirector, wardenObjective);
			LayoutRef[bulkhead] = levelLayout.PersistentId;
			wardenObjective.Build(buildDirector, this);
			ObjectiveLayerData objectiveLayerData = ObjectiveLayer[bulkhead];
			objectiveLayerData.ObjectiveData.DataBlockId = wardenObjective.PersistentId;
			if (buildDirector.Objective == WardenObjectiveType.ClearPath)
			{
				objectiveLayerData.ObjectiveData.WinCondition = WardenObjectiveWinCondition.GoToElevator;
			}
			Bins.WardenObjectives.AddBlock(wardenObjective);
		}

		public static Level Build(Level level)
		{
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Expected O, but got Unknown
			//IL_03d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d6: Expected O, but got Unknown
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Expected O, but got Unknown
			if (level.Name == "")
			{
				level.Name = Generator.Pick(Words.NounsLevel) ?? "";
			}
			string text = $"Level={level.Tier}{level.Index}";
			level.GenerateDepth();
			level.GenerateZoneAliasStarts();
			if (level.Settings == null)
			{
				level.Settings = new LevelSettings(level.Tier);
			}
			Bulkhead bulkhead = Generator.Select(new List<(double, Bulkhead)>
			{
				(0.25, Bulkhead.Main),
				(0.4, Bulkhead.Main | Bulkhead.Extreme),
				(0.1, Bulkhead.Main | Bulkhead.Overload),
				(0.25, Bulkhead.Objectives)
			});
			level.Settings.Bulkheads = bulkhead;
			if (level.Settings.Modifiers.Contains(LevelModifiers.Fog))
			{
				level.FogSettings = Fog.LowFog;
			}
			if (level.Settings.Modifiers.Contains(LevelModifiers.HeavyFog))
			{
				level.FogSettings = (Generator.Flip(0.75) ? Fog.LowFog : Fog.LowMidFog);
			}
			ManualLogSource logger = Plugin.Logger;
			bool flag = default(bool);
			BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(21, 3, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" - Modifiers: ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ModifiersSet>(level.Settings.Modifiers);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(", Fog: ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(level.FogSettings.Name);
			}
			logger.LogDebug(val);
			Generator.Select(new List<(double, string)> { (1.0, "chained") });
			level.BuildLayout(Bulkhead.Main);
			if (bulkhead.HasFlag(Bulkhead.Extreme))
			{
				level.BuildLayout(Bulkhead.Extreme);
			}
			if (bulkhead.HasFlag(Bulkhead.Overload))
			{
				level.BuildLayout(Bulkhead.Overload);
			}
			level.MainLayerData.BulkheadKeyPlacements.Add(new List<ZonePlacementData>
			{
				new ZonePlacementData
				{
					LocalIndex = 0,
					Weights = ZonePlacementWeights.NotAtStart
				}
			});
			if (bulkhead.HasFlag(Bulkhead.Extreme))
			{
				level.SecondaryLayerData.BulkheadKeyPlacements.Add(new List<ZonePlacementData>
				{
					new ZonePlacementData
					{
						LocalIndex = 0,
						Weights = ZonePlacementWeights.NotAtStart
					}
				});
			}
			if (bulkhead.HasFlag(Bulkhead.Overload))
			{
				level.ThirdLayerData.BulkheadKeyPlacements.Add(new List<ZonePlacementData>
				{
					new ZonePlacementData
					{
						LocalIndex = 0,
						Weights = ZonePlacementWeights.NotAtStart
					}
				});
			}
			foreach (ZoneNode bulkheadEntranceZone in level.Planner.GetBulkheadEntranceZones())
			{
				Zone zone = level.GetLevelLayout(bulkheadEntranceZone.Bulkhead)?.Zones[bulkheadEntranceZone.ZoneNumber];
				if (zone == null)
				{
					ManualLogSource logger2 = Plugin.Logger;
					BepInExWarningLogInterpolatedStringHandler val2 = new BepInExWarningLogInterpolatedStringHandler(72, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Level=");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(level.Tier);
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(level.Index);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" - Cannot resize ");
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("bulkhead entrance zone. Zone_");
						((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(bulkheadEntranceZone.ZoneNumber);
						((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" could not be found.");
					}
					logger2.LogWarning(val2);
				}
				else
				{
					zone.Coverage = new CoverageMinMax
					{
						Min = 80.0,
						Max = 80.0
					};
				}
			}
			ManualLogSource logger3 = Plugin.Logger;
			val = new BepInExDebugLogInterpolatedStringHandler(19, 3, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Level=");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(level.Tier);
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(level.Index);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" level plan: ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<LayoutPlanner>(level.Planner);
			}
			logger3.LogDebug(val);
			return level;
		}
	}
	public record Hibernating : Generator.ISelectable
	{
		public double Weight { get; set; } = 1.0;


		public uint Enemy { get; set; }
	}
	public record LevelLayout : DataBlock
	{
		public int ZoneAliasStart { get; set; }

		public List<Zone> Zones { get; set; } = new List<Zone>();


		[JsonIgnore]
		private Level level;

		[JsonIgnore]
		private BuildDirector director;

		[JsonIgnore]
		private LayoutPlanner planner;

		[JsonIgnore]
		private LevelSettings settings;

		public const double StartArea_TripleBulkheadChance = 0.2;

		public LevelLayout(Level level, BuildDirector director, LevelSettings settings, LayoutPlanner planner)
		{
			this.director = director;
			this.level = level;
			this.planner = planner;
			this.settings = settings;
		}

		public int ClampToZones(int value)
		{
			return Math.Clamp(value, 0, Zones.Count - 1);
		}

		public void RollAlarms(List<ChainedPuzzle> puzzlePack)
		{
			foreach (Zone zone in Zones)
			{
				zone.RollAlarms(puzzlePack);
			}
		}

		public unsafe void RollBloodDoors()
		{
			int num = 0;
			object obj = director.Tier switch
			{
				"A" => (0, 0.0, 0.0), 
				"B" => (1, 0.2, 0.3), 
				"C" => (2, 0.15, 0.5), 
				"D" => (3, 0.15, 0.5), 
				_ => (-1, 0.2, 0.7), 
			};
			int item = ((ValueTuple<int, double, double>*)(&obj))->Item1;
			double item2 = ((ValueTuple<int, double, double>*)(&obj))->Item2;
			double item3 = ((ValueTuple<int, double, double>*)(&obj))->Item3;
			List<VanillaEnemyGroup> collection = director.Tier switch
			{
				"B" => new List<VanillaEnemyGroup>
				{
					VanillaEnemyGroup.BloodDoor_Easy,
					VanillaEnemyGroup.BloodDoor_Easy,
					VanillaEnemyGroup.BloodDoor_Medium
				}, 
				"C" => new List<VanillaEnemyGroup>
				{
					VanillaEnemyGroup.BloodDoor_Easy,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Bigs,
					VanillaEnemyGroup.BloodDoor_Hybrids_Easy,
					VanillaEnemyGroup.BloodDoor_Hybrids_Medium
				}, 
				"D" => new List<VanillaEnemyGroup>
				{
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Bigs,
					VanillaEnemyGroup.BloodDoor_Bigs,
					VanillaEnemyGroup.BloodDoor_Chargers_Easy,
					VanillaEnemyGroup.BloodDoor_ChargersGiant_Easy,
					VanillaEnemyGroup.BloodDoor_Hybrids_Medium,
					VanillaEnemyGroup.BloodDoor_Hybrids_Medium,
					VanillaEnemyGroup.BloodDoor_Shadows_Easy,
					VanillaEnemyGroup.BloodDoor_BossMother
				}, 
				"E" => new List<VanillaEnemyGroup>
				{
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Bigs,
					VanillaEnemyGroup.BloodDoor_Bigs,
					VanillaEnemyGroup.BloodDoor_Chargers_Easy,
					VanillaEnemyGroup.BloodDoor_ChargersGiant_Easy,
					VanillaEnemyGroup.BloodDoor_Hybrids_Medium,
					VanillaEnemyGroup.BloodDoor_Hybrids_Medium,
					VanillaEnemyGroup.BloodDoor_Shadows_Easy,
					VanillaEnemyGroup.BloodDoor_BossMother,
					VanillaEnemyGroup.BloodDoor_BossMother
				}, 
				_ => new List<VanillaEnemyGroup>(), 
			};
			List<VanillaEnemyGroup> collection2 = director.Tier switch
			{
				"B" => new List<VanillaEnemyGroup>
				{
					VanillaEnemyGroup.BloodDoor_Easy,
					VanillaEnemyGroup.BloodDoor_Medium
				}, 
				"C" => new List<VanillaEnemyGroup>
				{
					VanillaEnemyGroup.BloodDoor_Easy,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Bigs,
					VanillaEnemyGroup.BloodDoor_Chargers_Easy,
					VanillaEnemyGroup.BloodDoor_Hybrids_Easy,
					VanillaEnemyGroup.BloodDoor_Shadows_Easy,
					VanillaEnemyGroup.BloodDoor_Pouncers
				}, 
				"D" => new List<VanillaEnemyGroup>
				{
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Bigs,
					VanillaEnemyGroup.BloodDoor_Bigs,
					VanillaEnemyGroup.BloodDoor_Chargers_Easy,
					VanillaEnemyGroup.BloodDoor_ChargersGiant_Easy,
					VanillaEnemyGroup.BloodDoor_Hybrids_Medium,
					VanillaEnemyGroup.BloodDoor_Hybrids_Medium,
					VanillaEnemyGroup.BloodDoor_Shadows_Easy,
					VanillaEnemyGroup.BloodDoor_BossMother,
					VanillaEnemyGroup.BloodDoor_Pouncers
				}, 
				"E" => new List<VanillaEnemyGroup>
				{
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Medium,
					VanillaEnemyGroup.BloodDoor_Bigs,
					VanillaEnemyGroup.BloodDoor_Bigs,
					VanillaEnemyGroup.BloodDoor_Chargers_Easy,
					VanillaEnemyGroup.BloodDoor_ChargersGiant_Easy,
					VanillaEnemyGroup.BloodDoor_Hybrids_Medium,
					VanillaEnemyGroup.BloodDoor_Hybrids_Medium,
					VanillaEnemyGroup.BloodDoor_Shadows_Easy,
					VanillaEnemyGroup.BloodDoor_BossMother,
					VanillaEnemyGroup.BloodDoor_Pouncers
				}, 
				_ => new List<VanillaEnemyGroup>(), 
			};
			foreach (Zone zone in Zones)
			{
				if (zone.LocalIndex > 0 && Generator.Flip(item2) && (num++ < item || item == -1))
				{
					bool flag = Generator.Flip(item3);
					zone.BloodDoor = new BloodDoor
					{
						EnemyGroupInfrontOfDoor = (uint)Generator.Draw(collection),
						EnemyGroupInArea = (uint)(flag ? Generator.Draw(collection2) : ((VanillaEnemyGroup)0u)),
						EnemyGroupsInArea = (flag ? 1 : 0)
					};
				}
			}
		}

		public unsafe void RollEnemies(BuildDirector director)
		{
			//IL_0727: Unknown result type (might be due to invalid IL or missing references)
			//IL_072e: Expected O, but got Unknown
			//IL_08de: Unknown result type (might be due to invalid IL or missing references)
			//IL_08e5: Expected O, but got Unknown
			object obj = director.Tier switch
			{
				"A" => (0.2, 2, new List<EnemySpawningData>
				{
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 5
					}
				}), 
				"B" => (0.2, 3, new List<EnemySpawningData>
				{
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 10
					}
				}), 
				"C" => (0.2, 5, new List<EnemySpawningData>
				{
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 10
					},
					EnemySpawningData.Scout with
					{
						Points = 10
					},
					EnemySpawningData.Scout with
					{
						Points = 15
					},
					EnemySpawningData.ScoutCharger with
					{
						Points = 5
					},
					EnemySpawningData.ScoutCharger with
					{
						Points = 5
					}
				}), 
				"D" => (0.3, -1, new List<EnemySpawningData>
				{
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 10
					},
					EnemySpawningData.Scout with
					{
						Points = 10
					},
					EnemySpawningData.Scout with
					{
						Points = 15
					},
					EnemySpawningData.ScoutCharger with
					{
						Points = 5
					},
					EnemySpawningData.ScoutCharger with
					{
						Points = 5
					},
					EnemySpawningData.ScoutCharger with
					{
						Points = 5
					},
					EnemySpawningData.ScoutCharger with
					{
						Points = 10
					},
					EnemySpawningData.ScoutShadow with
					{
						Points = 5
					},
					EnemySpawningData.ScoutShadow with
					{
						Points = 5
					},
					EnemySpawningData.ScoutShadow with
					{
						Points = 5
					},
					EnemySpawningData.ScoutShadow with
					{
						Points = 10
					}
				}), 
				"E" => (0.3, -1, new List<EnemySpawningData>
				{
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 5
					},
					EnemySpawningData.Scout with
					{
						Points = 10
					},
					EnemySpawningData.Scout with
					{
						Points = 10
					},
					EnemySpawningData.Scout with
					{
						Points = 15
					},
					EnemySpawningData.ScoutCharger with
					{
						Points = 5
					},
					EnemySpawningData.ScoutCharger with
					{
						Points = 5
					},
					EnemySpawningData.ScoutCharger with
					{
						Points = 5
					},
					EnemySpawningData.ScoutCharger with
					{
						Points = 10
					},
					EnemySpawningData.ScoutShadow with
					{
						Points = 5
					},
					EnemySpawningData.ScoutShadow with
					{
						Points = 5
					},
					EnemySpawningData.ScoutShadow with
					{
						Points = 5
					},
					EnemySpawningData.ScoutShadow with
					{
						Points = 10
					}
				}), 
				_ => (0.0, 0, new List<EnemySpawningData>()), 
			};
			double item = ((ValueTuple<double, int, List<EnemySpawningData>>*)(&obj))->Item1;
			int item2 = ((ValueTuple<double, int, List<EnemySpawningData>>*)(&obj))->Item2;
			List<EnemySpawningData> item3 = ((ValueTuple<double, int, List<EnemySpawningData>>*)(&obj))->Item3;
			double chance = director.Tier switch
			{
				"C" => 0.2, 
				"D" => 0.2, 
				"E" => 0.3, 
				_ => 0.0, 
			};
			int num = 0;
			bool flag = default(bool);
			foreach (Zone zone in Zones)
			{
				int num2 = director.GetPoints(zone);
				double num3 = (zone.BloodDoor.Enabled ? 0.5 : 1.0);
				if (Generator.Flip(item * num3) && (num++ < item2 || item2 == -1))
				{
					EnemySpawningData enemySpawningData = Generator.Draw(item3);
					if (enemySpawningData != null)
					{
						num2 = enemySpawningData.Points;
						for (int i = 0; i < enemySpawningData.Points / 5; i++)
						{
							zone.EnemySpawningInZone.Add(enemySpawningData with
							{
								Distribution = EnemyZoneDistribution.ForceOne,
								Points = 25
							});
						}
					}
				}
				if (num2 < 3)
				{
					continue;
				}
				if (zone.BloodDoor.Enabled)
				{
					num2 = (int)((double)num2 * 0.66);
				}
				double num4 = 0.0;
				if (settings.Modifiers.Contains(LevelModifiers.Chargers))
				{
					num4 = 0.2;
				}
				if (settings.Modifiers.Contains(LevelModifiers.ManyChargers))
				{
					num4 = 0.5;
				}
				double num5 = 0.0;
				if (settings.Modifiers.Contains(LevelModifiers.Shadows))
				{
					num5 = 0.15;
				}
				if (settings.Modifiers.Contains(LevelModifiers.ManyShadows))
				{
					num5 = 0.5;
				}
				double num6 = 0.0;
				if (settings.Modifiers.Contains(LevelModifiers.Hybrids))
				{
					num6 = 0.15;
				}
				BepInExDebugLogInterpolatedStringHandler val;
				if (Generator.Flip(chance) && settings.EnemyBossPack.Count() > 0)
				{
					zone.EnemySpawningInZone.Add(Generator.Draw(settings.EnemyBossPack));
					ManualLogSource logger = Plugin.Logger;
					val = new BepInExDebugLogInterpolatedStringHandler(24, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(base.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -- Zone ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(zone.LocalIndex);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" rolled a boss!");
					}
					logger.LogDebug(val);
				}
				List<(double, List<AutogenDifficulty>)> list = new List<(double, List<AutogenDifficulty>)>
				{
					(1.0, new List<AutogenDifficulty> { AutogenDifficulty.Base }),
					(num4, new List<AutogenDifficulty> { AutogenDifficulty.Chargers }),
					(num4, new List<AutogenDifficulty>
					{
						AutogenDifficulty.Base,
						AutogenDifficulty.Chargers
					}),
					(num5, new List<AutogenDifficulty> { AutogenDifficulty.Shadows }),
					(num5, new List<AutogenDifficulty>
					{
						AutogenDifficulty.Base,
						AutogenDifficulty.Shadows
					}),
					(num6, new List<AutogenDifficulty>
					{
						AutogenDifficulty.Base,
						AutogenDifficulty.Hybrids
					})
				};
				if (num4 > 0.0 && num5 > 0.0)
				{
					list.Add((0.2, new List<AutogenDifficulty>
					{
						AutogenDifficulty.Base,
						AutogenDifficulty.Chargers,
						AutogenDifficulty.Shadows
					}));
				}
				if (num4 > 0.0 && num5 > 0.0 && num6 > 0.0)
				{
					list.Add((0.1, new List<AutogenDifficulty>
					{
						AutogenDifficulty.Base,
						AutogenDifficulty.Chargers,
						AutogenDifficulty.Shadows,
						AutogenDifficulty.Hybrids
					}));
				}
				List<AutogenDifficulty> list2 = Generator.Select(list);
				ManualLogSource logger2 = Plugin.Logger;
				val = new BepInExDebugLogInterpolatedStringHandler(39, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(base.Name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -- Zone ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(zone.LocalIndex);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" has ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(num2);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("pts for enemies. Groups: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(string.Join(", ", list2));
				}
				logger2.LogDebug(val);
				foreach (AutogenDifficulty item4 in list2)
				{
					List<EnemySpawningData> enemySpawningInZone = zone.EnemySpawningInZone;
					EnemySpawningData enemySpawningData2 = new EnemySpawningData();
					enemySpawningData2.GroupType = EnemyGroupType.Hibernate;
					EnemySpawningData enemySpawningData3 = enemySpawningData2;
					enemySpawningData3.Difficulty = director.Tier switch
					{
						"A" => (uint)(AutogenDifficulty.TierA | item4), 
						"B" => (uint)(AutogenDifficulty.TierB | item4), 
						"C" => (uint)(AutogenDifficulty.TierC | item4), 
						"D" => (uint)(AutogenDifficulty.TierD | item4), 
						"E" => (uint)(AutogenDifficulty.TierE | item4), 
						_ => (uint)(AutogenDifficulty.TierC | item4), 
					};
					enemySpawningData2.Points = num2 / list2.Count();
					enemySpawningInZone.Add(enemySpawningData2);
				}
			}
		}

		public void RollErrorAlarm()
		{
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Expected O, but got Unknown
			int num = director.Tier switch
			{
				"A" => 0, 
				"B" => 0, 
				"C" => Roll(0.1), 
				"D" => Roll(0.3), 
				"E" => Roll(0.85), 
				_ => 0, 
			};
			if (num < 1)
			{
				return;
			}
			bool flag = default(bool);
			for (int i = 0; i < num; i++)
			{
				ChainedPuzzle alarmError_Baseline = ChainedPuzzle.AlarmError_Baseline;
				IEnumerable<Zone> enumerable = Zones.Where((Zone z) => z.LocalIndex != 0 && z.Alarm == ChainedPuzzle.None && z.LocalIndex != Zones.Count - 1);
				if (enumerable.Count() == 0)
				{
					enumerable = Zones.Where((Zone z) => z.LocalIndex != 0 && z.LocalIndex != Zones.Count - 1);
				}
				if (enumerable.Count() == 0)
				{
					enumerable = Zones.Where((Zone z) => z.LocalIndex != 0);
				}
				Zone zone = Generator.Pick(enumerable);
				if (zone == null)
				{
					break;
				}
				zone.Alarm = alarmError_Baseline;
				Bins.ChainedPuzzles.AddBlock(alarmError_Baseline);
				if (Generator.Flip())
				{
					zone.TurnOffAlarmOnTerminal = true;
					ZoneNode zoneNode = planner.GetZoneNode(zone.LocalIndex);
					List<ZoneNode> openZones = planner.GetOpenZones(director.Bulkhead, zoneNode.Branch);
					if (openZones.Count < 1)
					{
						openZones = planner.GetOpenZones(director.Bulkhead);
					}
					ZoneNode from = Generator.Pick(openZones);
					ZoneNode zoneNode2 = new ZoneNode(director.Bulkhead, planner.NextIndex(director.Bulkhead), $"error_off_{i}");
					planner.Connect(from, zoneNode2);
					planner.AddZone(zoneNode2, new Zone
					{
						Coverage = new CoverageMinMax(Generator.NextDouble(40.0, 80.0)),
						LightSettings = Lights.GenRandomLight()
					});
					Zone zone2 = planner.GetZone(zoneNode2);
					zone.EventsOnDoorScanDone.Add(new WardenObjectiveEvent
					{
						Type = WardenObjectiveEventType.UnlockSecurityDoor,
						LocalIndex = zoneNode2.ZoneNumber
					});
					zone2.ProgressionPuzzleToEnter = ProgressionPuzzle.Locked;
					ManualLogSource logger = Plugin.Logger;
					BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(46, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(base.Name);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -- Zone ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(zone.LocalIndex);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" error alarm can be disable in: Zone ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<int>(zoneNode2.ZoneNumber);
					}
					logger.LogDebug(val);
					zone.TerminalPuzzleZone.LocalIndex = zoneNode2.ZoneNumber;
					Zones.Add(zone2);
				}
			}
			static int Roll(double chance)
			{
				if (Generator.Flip(chance))
				{
					return 1 + Roll(chance - 0.4);
				}
				return 0;
			}
		}

		public void RollKeyedDoors(BuildDirector director, LayoutPlanner planner, ICollection<ChainedPuzzle> puzzlePack)
		{
			//IL_027f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Expected O, but got Unknown
			if (Generator.Flip(0.6))
			{
				return;
			}
			ZoneNode node = Generator.Pick(planner.GetZonesWithTotalOpen(0, 2, director.Bulkhead));
			List<ZoneNode> connections = planner.GetConnections(node);
			ZoneNode lockedZone = Generator.Pick(connections);
			Zone zone = Zones[node.ZoneNumber];
			string branch = "key1";
			int num = director.Tier switch
			{
				"A" => 1, 
				"B" => 1, 
				"C" => Generator.Select(new List<WeightedValue<int>>
				{
					new WeightedValue<int>
					{
						Value = 1,
						Weight = 0.66
					},
					new WeightedValue<int>
					{
						Value = 2,
						Weight = 0.33
					}
				}).Value, 
				"D" => Generator.Select(new List<WeightedValue<int>>
				{
					new WeightedValue<int>
					{
						Value = 1,
						Weight = 0.66
					},
					new WeightedValue<int>
					{
						Value = 2,
						Weight = 0.33
					}
				}).Value, 
				"E" => Generator.Select(new List<WeightedValue<int>>
				{
					new WeightedValue<int>
					{
						Value = 1,
						Weight = 0.66
					},
					new WeightedValue<int>
					{
						Value = 2,
						Weight = 0.33
					}
				}).Value, 
				_ => 1, 
			};
			bool flag = default(bool);
			for (int i = 0; i < num; i++)
			{
				ZoneNode zoneNode = planner.GetLastZone(director.Bulkhead, branch) ?? new ZoneNode(director.Bulkhead, zone.LocalIndex);
				Zone zone2 = new Zone
				{
					LocalIndex = planner.NextIndex(director.Bulkhead),
					BuildFromLocalIndex = zoneNode.ZoneNumber,
					Coverage = CoverageMinMax.GenSize(i),
					LightSettings = Lights.GenRandomLight()
				};
				planner.Connect(zoneNode, new ZoneNode(director.Bulkhead, zone2.LocalIndex, branch));
				ManualLogSource logger = Plugin.Logger;
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(18, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Adding zones: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ZoneNode>(zoneNode);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -> ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<ZoneNode>(new ZoneNode(director.Bulkhead, zone2.LocalIndex, branch));
				}
				logger.LogDebug(val);
				zone2.RollAlarms(puzzlePack);
				Zones.Add(zone2);
			}
			Zones.Find((Zone z) => z.LocalIndex == lockedZone.ZoneNumber).ProgressionPuzzleToEnter = new ProgressionPuzzle
			{
				PuzzleType = ProgressionPuzzleType.Keycard,
				ZonePlacementData = new List<ZonePlacementData>
				{
					new ZonePlacementData
					{
						LocalIndex = planner.GetZones(director.Bulkhead, branch).Last().ZoneNumber
					}
				}
			};
		}

		public static SubComplex GenSubComplex(Complex complex)
		{
			return complex switch
			{
				Complex.Mining => Generator.Pick(new List<SubComplex>
				{
					SubComplex.DigSite,
					SubComplex.Refinery,
					SubComplex.Storage
				}), 
				Complex.Tech => Generator.Pick(new List<SubComplex>
				{
					SubComplex.DataCenter,
					SubComplex.Lab
				}), 
				Complex.Service => Generator.Pick(new List<SubComplex>
				{
					SubComplex.Floodways,
					SubComplex.Gardens
				}), 
				_ => SubComplex.All, 
			};
		}

		private ZoneNode BuildBranch(ZoneNode baseNode, int zoneCount, string branch = "primary")
		{
			ZoneNode zoneNode = baseNode;
			if (zoneCount < 1)
			{
				return zoneNode;
			}
			for (int i = 0; i < zoneCount; i++)
			{
				int zoneNumber = level.Planner.NextIndex(director.Bulkhead);
				ZoneNode zoneNode2 = new ZoneNode(director.Bulkhead, zoneNumber, branch);
				Zone zone = new Zone
				{
					Coverage = CoverageMinMax.GenNormalSize(),
					LightSettings = Lights.GenRandomLight()
				};
				zone.RollFog(level);
				level.Planner.Connect(zoneNode, zoneNode2);
				level.Planner.AddZone(zoneNode2, zone);
				zoneNode = zoneNode2;
			}
			return zoneNode;
		}

		public static LevelLayout Build(Level level, BuildDirector director, WardenObjective objective)
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Expected O, but got Unknown
			//IL_0ebf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ec6: Expected O, but got Unknown
			//IL_0f58: Unknown result type (might be due to invalid IL or missing references)
			//IL_0f5f: Expected O, but got Unknown
			Level level2 = level;
			BuildDirector director2 = director;
			LevelLayout levelLayout = new LevelLayout(level2, director2, level2.Settings, level2.Planner)
			{
				Name = $"{level2.Tier}{level2.Index} {level2.Name} {director2.Bulkhead}",
				ZoneAliasStart = level2.GetZoneAliasStart(director2.Bulkhead)
			};
			director2.GenZones();
			level2.GetObjectiveLayerData(director2.Bulkhead);
			List<ChainedPuzzle> puzzlePack = ChainedPuzzle.BuildPack(level2.Tier);
			ManualLogSource logger = Plugin.Logger;
			bool flag = default(bool);
			BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(32, 2, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Building layout (");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(levelLayout.Name);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("), Objective = ");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<WardenObjectiveType>(objective.Type);
			}
			logger.LogDebug(val);
			BuildStartingArea(level2, director2);
			switch (director2.Objective)
			{
			case WardenObjectiveType.ReactorStartup:
			{
				ZoneNode start = level2.Planner.GetExactZones(director2.Bulkhead).First();
				if (objective.ReactorStartupGetCodes)
				{
					levelLayout.BuildLayout_ReactorStartup_FetchCodes(director2, objective, start);
				}
				else
				{
					levelLayout.BuildLayout_ReactorStartup_Simple(director2, objective, start);
				}
				break;
			}
			case WardenObjectiveType.ReactorShutdown:
			{
				ZoneNode from = level2.Planner.GetExactZones(director2.Bulkhead).First();
				int num = Generator.Random.Next(0, director2.ZoneCount);
				for (int j = 0; j < num; j++)
				{
					int zoneNumber2 = level2.Planner.NextIndex(director2.Bulkhead);
					ZoneNode zoneNode3 = new ZoneNode(director2.Bulkhead, zoneNumber2);
					level2.Planner.Connect(from, zoneNode3);
					level2.Planner.AddZone(zoneNode3, new Zone
					{
						Coverage = CoverageMinMax.GenNormalSize(),
						LightSettings = Lights.GenRandomLight()
					});
					from = zoneNode3;
				}
				(ZoneBuildExpansion, ZoneExpansion) tuple = Generator.Pick(new List<(ZoneBuildExpansion, ZoneExpansion)>
				{
					(ZoneBuildExpansion.Left, ZoneExpansion.Left),
					(ZoneBuildExpansion.Right, ZoneExpansion.Right),
					(ZoneBuildExpansion.Forward, ZoneExpansion.Forward),
					(ZoneBuildExpansion.Backward, ZoneExpansion.Backward)
				});
				ZoneBuildExpansion item = tuple.Item1;
				ZoneExpansion item2 = tuple.Item2;
				Lights.Light lightSettings = Lights.GenReactorLight();
				ZoneNode zoneNode4 = new ZoneNode(director2.Bulkhead, level2.Planner.NextIndex(director2.Bulkhead));
				Zone zone3 = new Zone
				{
					LightSettings = lightSettings,
					StartPosition = ZoneEntranceBuildFrom.Furthest,
					StartExpansion = item,
					ZoneExpansion = item2
				};
				zone3.GenReactorCorridorGeomorph(director2.Complex);
				level2.Planner.Connect(from, zoneNode4);
				level2.Planner.AddZone(zoneNode4, zone3);
				ZoneNode zoneNode5 = new ZoneNode(director2.Bulkhead, level2.Planner.NextIndex(director2.Bulkhead));
				Zone zone4 = new Zone
				{
					LightSettings = lightSettings,
					StartPosition = ZoneEntranceBuildFrom.Furthest,
					StartExpansion = item,
					ZoneExpansion = item2,
					ForbidTerminalsInZone = true
				};
				zone4.GenReactorGeomorph(director2.Complex);
				zone4.TerminalPlacements = new List<TerminalPlacement>();
				level2.Planner.Connect(zoneNode4, zoneNode5);
				level2.Planner.AddZone(zoneNode5, zone4);
				break;
			}
			case WardenObjectiveType.ClearPath:
			{
				ZoneNode zoneNode15 = level2.Planner.GetExactZones(director2.Bulkhead).First();
				for (int num5 = 1; num5 < director2.ZoneCount; num5++)
				{
					int zoneNumber7 = level2.Planner.NextIndex(director2.Bulkhead);
					ZoneNode zoneNode16 = new ZoneNode(director2.Bulkhead, zoneNumber7);
					Zone zone12 = new Zone
					{
						Coverage = CoverageMinMax.GenNormalSize(),
						LightSettings = Lights.GenRandomLight()
					};
					zone12.RollFog(level2);
					level2.Planner.Connect(zoneNode15, zoneNode16);
					level2.Planner.AddZone(zoneNode16, zone12);
					zoneNode15 = zoneNode16;
				}
				ZoneNode node3 = zoneNode15;
				Zone? zone13 = level2.Planner.GetZone(node3);
				ZoneNode value3 = level2.Planner.GetBuildFrom(node3).Value;
				Zone? zone14 = level2.Planner.GetZone(value3);
				SubComplex subComplex = GenSubComplex(level2.Complex);
				zone14.ZoneExpansion = ZoneExpansion.Expansional;
				zone14.Coverage = new CoverageMinMax
				{
					Min = 35.0,
					Max = 45.0
				};
				zone13.StartPosition = ZoneEntranceBuildFrom.Furthest;
				zone13.Coverage = new CoverageMinMax
				{
					Min = 50.0,
					Max = 50.0
				};
				zone13.SubComplex = subComplex;
				zone13.GenExitGeomorph(level2.Complex);
				break;
			}
			case WardenObjectiveType.RetrieveBigItems:
			{
				int num2 = objective.RetrieveItems.Count();
				WardenObjectiveItem num3 = objective.RetrieveItems.First();
				ZoneNode zoneNode8 = level2.Planner.GetExactZones(director2.Bulkhead).First()with
				{
					MaxConnections = 3
				};
				Zone? zone5 = level2.Planner.GetZone(zoneNode8);
				zone5.GenHubGeomorph(director2.Complex);
				zone5.RollFog(level2);
				ZoneNode zoneNode9 = new ZoneNode(ZoneNumber: level2.Planner.NextIndex(director2.Bulkhead), Bulkhead: director2.Bulkhead)
				{
					MaxConnections = 1
				};
				Zone zone6 = new Zone
				{
					LightSettings = Lights.GenRandomLight()
				};
				zone6.GenCorridorGeomorph(director2.Complex);
				zone6.RollFog(level2);
				level2.Planner.Connect(zoneNode8, zoneNode9);
				level2.Planner.AddZone(zoneNode9, zone6);
				ZoneNode zoneNode10 = new ZoneNode(ZoneNumber: level2.Planner.NextIndex(director2.Bulkhead), Bulkhead: director2.Bulkhead)
				{
					MaxConnections = 3
				};
				Zone zone7 = new Zone
				{
					LightSettings = Lights.GenRandomLight()
				};
				zone7.GenHubGeomorph(director2.Complex);
				zone7.RollFog(level2);
				level2.Planner.Connect(zoneNode9, zoneNode10);
				level2.Planner.AddZone(zoneNode10, zone7);
				if (num3 == WardenObjectiveItem.MatterWaveProjector)
				{
					BuildLayout_MatterWaveProjector(level2, director2, objective, zoneNode10);
					break;
				}
				for (int l = 0; l < Math.Min(num2, 3); l++)
				{
					ZoneNode baseNode2 = zoneNode10;
					string branch2 = $"bigitem_{l}";
					BuildItemBranch(baseNode2, branch2, num2 switch
					{
						1 => (5, 7), 
						2 => (3, 5), 
						_ => (2, 3), 
					});
				}
				if (num2 > 3)
				{
					ZoneNode value = level2.Planner.GetLastZone(director2.Bulkhead, "bigitem_2").Value;
					ZoneNode zoneNode11 = new ZoneNode(director2.Bulkhead, level2.Planner.NextIndex(director2.Bulkhead));
					zoneNode11.MaxConnections = 3;
					Zone zone8 = new Zone
					{
						LightSettings = Lights.GenRandomLight()
					};
					zone8.GenHubGeomorph(director2.Complex);
					zone8.RollFog(lev