using System;
using System.Collections;
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.Enums;
using AutogenRundown.DataBlocks.Items;
using AutogenRundown.DataBlocks.Levels;
using AutogenRundown.DataBlocks.Objectives;
using AutogenRundown.DataBlocks.Objectives.Reactor;
using AutogenRundown.DataBlocks.Terminals;
using AutogenRundown.DataBlocks.ZoneData;
using AutogenRundown.DataBlocks.Zones;
using AutogenRundown.GeneratorData;
using AutogenRundown.Patches;
using AutogenRundown.Utils;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using BoosterImplants;
using CellMenu;
using GameData;
using HarmonyLib;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using TMPro;
using UnityEngine;
using XXHashing;

[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+fd004c034ed1b2be8a5ba55343178c10b704fc09")]
[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 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,
				WardenObjectiveType.Survival
			};
			list.RemoveAll((WardenObjectiveType o) => exclude2.Contains(o));
			if (!Bulkhead.HasFlag(Bulkhead.Main))
			{
				list.Remove(WardenObjectiveType.ClearPath);
				list.Remove(WardenObjectiveType.Survival);
			}
			if (Bulkhead.HasFlag(Bulkhead.Main))
			{
				list.Remove(WardenObjectiveType.SpecialTerminalCommand);
			}
			if (Complex != Complex.Mining || Complex != Complex.Tech)
			{
				list.Remove(WardenObjectiveType.CentralGeneratorCluster);
			}
			if (Bulkhead.HasFlag(Bulkhead.Overload) && exclude2.Contains(WardenObjectiveType.Survival))
			{
				list = new List<WardenObjectiveType> { WardenObjectiveType.SpecialTerminalCommand };
			}
			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.Select(new List<(double, int)>
				{
					(0.4, 1),
					(1.0, 2)
				}) : Generator.Select(new List<(double, int)>
				{
					(0.4, 1),
					(1.0, 2),
					(1.0, 3)
				}), 
				"B" => (bulkhead != Bulkhead.Main) ? Generator.Select(new List<(double, int)>
				{
					(0.4, 1),
					(1.0, 2),
					(1.0, 3)
				}) : Generator.Select(new List<(double, int)>
				{
					(0.4, 2),
					(1.0, 3),
					(1.0, 4),
					(0.2, 5)
				}), 
				"C" => (bulkhead != Bulkhead.Main) ? Generator.Select(new List<(double, int)>
				{
					(0.3, 1),
					(0.9, 2),
					(1.0, 3)
				}) : Generator.Select(new List<(double, int)>
				{
					(0.9, 3),
					(1.0, 4),
					(1.0, 5)
				}), 
				"D" => (bulkhead != Bulkhead.Main) ? Generator.Select(new List<(double, int)>
				{
					(0.6, 2),
					(0.9, 3),
					(1.0, 4)
				}) : Generator.Select(new List<(double, int)>
				{
					(0.6, 3),
					(0.9, 4),
					(1.0, 5),
					(0.3, 6)
				}), 
				"E" => (bulkhead != Bulkhead.Main) ? Generator.Select(new List<(double, int)>
				{
					(0.5, 2),
					(1.0, 3),
					(1.0, 4),
					(0.1, 5)
				}) : Generator.Select(new List<(double, int)>
				{
					(0.4, 3),
					(0.9, 4),
					(1.0, 5),
					(0.8, 6),
					(0.1, 7)
				}), 
				_ => 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 * zone.EnemyPointsMultiplier;
			return (int)(num * (double)(Tier switch
			{
				"A" => Generator.Random.Next(20, 25), 
				"B" => Generator.Random.Next(23, 27), 
				"C" => Generator.Random.Next(25, 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 class ComplexResourceSet
	{
		private const string FileName = "GameData_ComplexResourceSetDataBlock_bin.json";

		private JObject resourceSet;

		public ComplexResourceSet()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Expected O, but got Unknown
			using StreamReader streamReader = File.OpenText(Path.Combine(Paths.PluginPath, "the_tavern-AutogenRundown", "GameData_ComplexResourceSetDataBlock_bin.json"));
			JsonTextReader val = new JsonTextReader((TextReader)streamReader);
			try
			{
				resourceSet = (JObject)JToken.ReadFrom((JsonReader)(object)val);
				if (resourceSet["Blocks"] == null)
				{
					Plugin.Logger.LogFatal((object)"No complex resource set data blocks found");
					throw new Exception("No complex resource set data blocks found");
				}
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		private void WriteFile()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			int revision = CellBuildData.GetRevision();
			Path.Combine(Paths.PluginPath, "the_tavern-AutogenRundown", "GameData_ComplexResourceSetDataBlock_bin.json");
			string text = Path.Combine(Paths.BepInExRootPath, "GameData", $"{revision}");
			string path = Path.Combine(text, "GameData_ComplexResourceSetDataBlock_bin.json");
			Directory.CreateDirectory(text);
			using StreamWriter streamWriter = File.CreateText(path);
			JsonTextWriter val = new JsonTextWriter((TextWriter)streamWriter);
			try
			{
				((JToken)resourceSet).WriteTo((JsonWriter)(object)val, Array.Empty<JsonConverter>());
			}
			finally
			{
				((IDisposable)val)?.Dispose();
			}
		}

		public JArray GetPrefabs(int persistentId, string group)
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Expected O, but got Unknown
			JObject obj = ((IEnumerable)resourceSet["Blocks"]).OfType<JObject>().First((JObject block) => (int?)block["persistentID"] == persistentId);
			if (obj[group] == null)
			{
				Plugin.Logger.LogFatal((object)"No complex resource set data blocks found");
				throw new Exception("No complex resource set data blocks found");
			}
			return (JArray)obj[group];
		}

		public JArray GetPrefabs(Complex complex, string group)
		{
			return GetPrefabs((int)complex, group);
		}

		public void AddPrefab(Complex complex, string group, Prefab prefab)
		{
			GetPrefabs(complex, group).Insert(0, (JToken)(object)JObject.FromObject((object)prefab));
		}

		public static void Setup()
		{
			ComplexResourceSet complexResourceSet = new ComplexResourceSet();
			complexResourceSet.AddPrefab(Complex.Mining, "GeomorphTiles_1x1", new Prefab
			{
				Asset = "Assets/Prefabs/Geomorph/Mining/geo_storage_FA_01.prefab",
				SubComplex = SubComplex.Storage
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Prefabs/Geomorph/Mining/geo_storage_FA_dead_end_01.prefab",
				SubComplex = SubComplex.Storage
			});
			complexResourceSet.AddPrefab(Complex.Tech, "GeomorphTiles_1x1", new Prefab
			{
				Asset = "Assets/Prefabs/Geomorph/Tech/geo_lab_FA_01.prefab",
				SubComplex = SubComplex.Lab
			});
			complexResourceSet.AddPrefab(Complex.Tech, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Prefabs/Geomorph/Tech/geo_lab_FA_dead_end_01.prefab",
				SubComplex = SubComplex.Lab
			});
			complexResourceSet.AddPrefab(Complex.Tech, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Prefabs/Geomorph/Tech/geo_datacenter_FA_I_01.prefab",
				SubComplex = SubComplex.DataCenter
			});
			complexResourceSet.AddPrefab(Complex.Tech, "CustomGeomorphs_Exit_1x1", new Prefab
			{
				Asset = "Assets/Prefabs/Geomorph/Tech/geo_datacenter_FA_exit_01.prefab",
				SubComplex = SubComplex.DataCenter
			});
			complexResourceSet.AddPrefab(Complex.Tech, "ElevatorShafts_1x1", new Prefab
			{
				Asset = "Assets/Prefabs/Geomorph/Tech/geo_datacenter_FA_elevator_shaft_01.prefab",
				SubComplex = SubComplex.DataCenter
			});
			complexResourceSet.AddPrefab(Complex.Tech, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Prefabs/Geomorph/Service/geo_floodways_FA_reactor_01.prefab",
				SubComplex = SubComplex.Floodways
			});
			complexResourceSet.WriteFile();
		}
	}
	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; }
		}

		public static uint pid = 100000u;

		private static uint enemyGroupPid = 80u;

		private static uint wavePopulationPid = 200u;

		private static uint waveSettingsPid = 1u;

		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 int Between(int min, int max)
		{
			return Random.Next(min, max + 1);
		}

		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 T DrawSelect<T>(ICollection<(double, int, T)> collection, bool fixedWeights = false)
		{
			double num = collection.Sum<(double, int, T)>(((double, int, T) x) => fixedWeights ? x.Item1 : (x.Item1 * (double)x.Item2));
			double num2 = Random.NextDouble() * num;
			double num3 = 0.0;
			for (int i = 0; i < collection.Count; i++)
			{
				(double, int, T) tuple = collection.ElementAt(i);
				(double, int, T) tuple2 = tuple;
				double item = tuple2.Item1;
				int item2 = tuple2.Item2;
				T item3 = tuple2.Item3;
				num3 += item * (double)item2;
				if (num2 <= num3)
				{
					collection.Remove(tuple);
					tuple.Item2--;
					if (tuple.Item2 > 0)
					{
						collection.Add(tuple);
					}
					return item3;
				}
			}
			(double, int, T) item4 = collection.Last();
			collection.Remove(item4);
			item4.Item2--;
			if (item4.Item2 > 0)
			{
				collection.Add(item4);
			}
			return item4.Item3;
		}

		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.38.1")]
	[BepInProcess("GTFO.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		public const string Version = "0.38.1";

		public const string Name = "the_tavern-AutogenRundown";

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


		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 record Prefab
	{
		[JsonProperty("Prefab")]
		public string Asset { get; set; } = "";


		public SubComplex SubComplex { get; set; } = SubComplex.All;


		public string Shard { get; set; } = "S1";

	}
	public static class RundownFactory
	{
		private static string DescriptionHeader(WardenObjectiveType objectiveType)
		{
			string text = "<color=#444444>Objective Dispatch:</color> ";
			return objectiveType switch
			{
				WardenObjectiveType.HsuFindSample => text + "<color=orange>HSU Extraction</color>\n", 
				WardenObjectiveType.ReactorStartup => text + "<color=orange>Reactor Startup</color>\n", 
				WardenObjectiveType.ReactorShutdown => text + "<color=orange>Reactor Shutdown</color>\n", 
				WardenObjectiveType.GatherSmallItems => text + "<color=orange>Gather Items</color>\n", 
				WardenObjectiveType.ClearPath => text + "<color=orange>Sector Survey</color>\n", 
				WardenObjectiveType.SpecialTerminalCommand => text + "<color=orange>Manual Terminal Override</color>\n", 
				WardenObjectiveType.RetrieveBigItems => text + "<color=orange>Package Extraction</color>\n", 
				WardenObjectiveType.PowerCellDistribution => text + "<color=orange>Power Cell Distribution</color>\n", 
				WardenObjectiveType.TerminalUplink => text + "<color=orange>Network Uplink</color>\n", 
				WardenObjectiveType.Survival => text + "<color=orange>Diversion Protocol</color>\n", 
				WardenObjectiveType.TimedTerminalSequence => text + "<color=orange>Timed Sequence</color>\n", 
				_ => "", 
			};
		}

		public static void Build()
		{
			Generator.Reload();
			Bins.Setup();
			ComplexResourceSet.Setup();
			Rundown rundown = Rundown.Build(new Rundown
			{
				PersistentId = Rundown.R7
			});
			List<string> collection = Words.NewLevelNamesPack();
			int num = Generator.Between(1, 2);
			int num2 = Generator.Between(3, 4);
			int num3 = Generator.Between(2, 4);
			int num4 = Generator.Between(1, 2);
			int num5 = Generator.Between(1, 4);
			for (int i = 0; i < num; i++)
			{
				Level level = Level.Build(new Level("A")
				{
					Name = Generator.Draw(collection),
					Index = i + 1
				});
				rundown.AddLevel(level);
			}
			for (int j = 0; j < num2; j++)
			{
				Level level2 = Level.Build(new Level("B")
				{
					Name = Generator.Draw(collection),
					Index = j + 1
				});
				rundown.AddLevel(level2);
			}
			for (int k = 0; k < num3; k++)
			{
				Level level3 = Level.Build(new Level("C")
				{
					Name = Generator.Draw(collection),
					Index = k + 1
				});
				rundown.AddLevel(level3);
			}
			WardenObjectiveType wardenObjectiveType = WardenObjectiveType.Survival;
			BuildDirector buildDirector = new BuildDirector
			{
				Bulkhead = Bulkhead.Main,
				Complex = Complex.Tech,
				Tier = "D",
				Objective = wardenObjectiveType
			};
			buildDirector.GenPoints();
			LevelSettings levelSettings = new LevelSettings("D");
			levelSettings.Modifiers.Add(LevelModifiers.Chargers);
			AutogenRundown.DataBlocks.Text text = new AutogenRundown.DataBlocks.Text(DescriptionHeader(wardenObjectiveType) + WardenObjective.GenLevelDescription(wardenObjectiveType));
			Level level4 = Level.Build(new Level("D")
			{
				Prefix = "<color=orange>X</color><color=#444444>:</color>D",
				Description = text.PersistentId,
				Complex = Complex.Tech,
				MainDirector = buildDirector,
				Settings = levelSettings,
				Index = 1
			});
			rundown.AddLevel(level4);
			for (int l = 1; l < num4 + 1; l++)
			{
				Level level5 = Level.Build(new Level("D")
				{
					Name = Generator.Draw(collection),
					Index = l + 1
				});
				rundown.AddLevel(level5);
			}
			WardenObjectiveType wardenObjectiveType2 = WardenObjectiveType.TimedTerminalSequence;
			BuildDirector buildDirector2 = new BuildDirector
			{
				Bulkhead = Bulkhead.Main,
				Complex = Complex.Mining,
				Tier = "D",
				Objective = wardenObjectiveType2
			};
			buildDirector2.GenPoints();
			LevelSettings settings = new LevelSettings("D");
			AutogenRundown.DataBlocks.Text text2 = new AutogenRundown.DataBlocks.Text(DescriptionHeader(wardenObjectiveType2) + WardenObjective.GenLevelDescription(wardenObjectiveType2));
			Level level6 = Level.Build(new Level("D")
			{
				Prefix = "<color=orange>W</color><color=#444444>:</color>D",
				Description = text2.PersistentId,
				Complex = Complex.Mining,
				MainDirector = buildDirector2,
				Settings = settings,
				Index = num4 + 2
			});
			rundown.AddLevel(level6);
			WardenObjectiveType wardenObjectiveType3 = WardenObjectiveType.ReactorStartup;
			BuildDirector buildDirector3 = new BuildDirector
			{
				Bulkhead = Bulkhead.Main,
				Tier = "D",
				Objective = wardenObjectiveType3
			};
			buildDirector3.GenPoints();
			LevelSettings settings2 = new LevelSettings("D");
			AutogenRundown.DataBlocks.Text text3 = new AutogenRundown.DataBlocks.Text(DescriptionHeader(wardenObjectiveType3) + WardenObjective.GenLevelDescription(wardenObjectiveType3));
			Level level7 = Level.Build(new Level("D")
			{
				Prefix = "<color=orange>R</color><color=#444444>:</color>D",
				Description = text3.PersistentId,
				MainDirector = buildDirector3,
				Settings = settings2,
				Index = num4 + 3
			});
			rundown.AddLevel(level7);
			for (int m = 0; m < num5; m++)
			{
				Level level8 = Level.Build(new Level("E")
				{
					Name = Generator.Draw(collection),
					Index = m + 1
				});
				rundown.AddLevel(level8);
			}
			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.Utils
{
	public class Tags
	{
		private HashSet<string> tags = new HashSet<string>();

		public Tags(params string[] initialTags)
		{
			foreach (string item in initialTags)
			{
				tags.Add(item);
			}
		}

		public bool Add(string tag)
		{
			return tags.Add(tag);
		}

		public bool Contains(string tag)
		{
			return tags.Contains(tag);
		}

		public override string ToString()
		{
			return "{" + string.Join(", ", tags.ToArray()) + "}";
		}
	}
}
namespace AutogenRundown.Patches
{
	[HarmonyPatch(typeof(ArtifactInventory), "GetArtifactCountAndBoosterValue")]
	public class Artifacts
	{
		public static void Postfix(ref ArtifactCountBoosterValuePair __result, ArtifactCategory category, bool prePickup = false)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogInfo((object)($"BoosterImplants.ArtifactInventory.GetArtifactCountAndBoosterValue() called with: {category} -- " + "{" + $"{__result.ArtifactCount}, {__result.BoosterValue}" + "}"));
		}
	}
	public class LevelGenPatcher
	{
		public static LG_ZoneJob_CreateExpandFromData currentZone;

		[HarmonyFinalizer]
		[HarmonyPatch(typeof(LG_ZoneJob_CreateExpandFromData), "Build")]
		public static void BuildFinalizer(LG_ZoneJob_CreateExpandFromData __instance, ref Exception __exception, ref bool __result)
		{
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			currentZone = __instance;
			bool flag = default(bool);
			if (__exception != null)
			{
				ManualLogSource logger = Plugin.Logger;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(22, 4, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("We failed ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(__instance.m_zone.AliasName);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -- ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<float>(__instance.m_zone.m_coverage);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -- ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<uint>(__instance.m_subSeed);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -- ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<uint>(__instance.m_zone.m_subSeed);
				}
				logger.LogInfo(val);
				__instance.CleanupFailedZoneBuilds();
				LG_Zone zone = __instance.m_zone;
				uint subSeed = zone.m_subSeed;
				zone.m_subSeed = subSeed + 1;
				subSeed = __instance.m_subSeed;
				__instance.m_subSeed = subSeed + 1;
				__result = true;
			}
			else
			{
				ManualLogSource logger2 = Plugin.Logger;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(17, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Building ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(__instance.m_zone.AliasName);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -- ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(((Object)__instance.m_zone.m_sourceExpander).name);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" -- ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<bool>(__result);
				}
				logger2.LogInfo(val);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(LG_FunctionMarkerBuilder), "BuildMarkerSpawnerRec")]
		public static void MarkerPatch(LG_FunctionMarkerBuilder __instance, ref LG_MarkerSpawner markerSpawner, ref ExpeditionFunction function)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			Plugin.Logger.LogInfo((object)"We're Functioning");
			ExpeditionFunction val = function;
			bool flag = false;
			if (markerSpawner == null)
			{
				return;
			}
			if ((Object)(object)markerSpawner.m_zone == (Object)null && !markerSpawner.AllowFunction())
			{
				LG_MarkerProducer producerSource = markerSpawner.m_producerSource;
				((Object)producerSource).name = ((Object)producerSource).name + "_FuncNotAllowed";
				val = (ExpeditionFunction)0;
			}
			XXHashSequence val2 = default(XXHashSequence);
			((XXHashSequence)(ref val2))..ctor(XXHash.Hash(markerSpawner.m_markerInstanceSeed, 973686256u, true), true);
			if ((Object)(object)LG_MarkerFactory.InstantiateMarkerGameObject(markerSpawner, val, ((XXHashSequence)(ref val2)).NextFloat(), ((XXHashSequence)(ref val2)).NextFloat(), ((XXHashSequence)(ref val2)).NextRange(-1f, 1f), ref flag, false) == (Object)null)
			{
				Plugin.Logger.LogInfo((object)(((object)(ExpeditionFunction)(ref val)).ToString() + " Did not function correctly"));
				if (((object)(ExpeditionFunction)(ref val)).ToString() == "PowerGenerator")
				{
					Plugin.Logger.LogInfo((object)"OPPSSS... This was really important.... REROLLL");
					currentZone.CleanupFailedZoneBuilds();
					LG_Zone zone = currentZone.m_zone;
					uint subSeed = zone.m_subSeed;
					zone.m_subSeed = subSeed + 1;
					LG_ZoneJob_CreateExpandFromData obj = currentZone;
					subSeed = obj.m_subSeed;
					obj.m_subSeed = subSeed + 1;
				}
			}
		}
	}
	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)
				{
					string text = Bins.Rundowns.Find(Rundown.R7)?.DisplaySeed;
					if (text == "")
					{
						text = "<color=orange>" + Generator.Seed + "</color>";
					}
					((TMP_Text)current.m_rundownText).text = "<size=60%><color=green>RND</color><color=#444444>://</color></size>R" + text;
				}
				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.38.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[] Level_FirstWord = new string[100]
		{
			"Abandon", "Agony", "Anomaly", "Apparition", "Ashes", "Asylum", "Banishment", "Banshee", "Barrow", "Betrayal",
			"Charnel", "Collapse", "Corruption", "Crypt", "Cursed", "Darkness", "Decay", "Deception", "Decrepit", "Defilement",
			"Dementia", "Derelict", "Despair", "Detritus", "Dread", "Echoes", "Eclipse", "Eldritch", "Emptiness", "Enigma",
			"Erosion", "Evocation", "Extinction", "Faded", "Fallen", "Famine", "Fissure", "Forsaken", "Fright", "Ghost",
			"Gloom", "Grave", "Grim", "Haunted", "Havoc", "Horror", "Hostility", "Inferno", "Isolation", "Labyrinth",
			"Lament", "Leviathan", "Lurking", "Malevolent", "Malice", "Menace", "Mire", "Misery", "Morbid", "Mournful",
			"Nightmare", "Oblivion", "Omen", "Pandemonium", "Paranoia", "Perdition", "Phantom", "Plague", "Portal", "Ravine",
			"Reaper", "Ruin", "Shadows", "Sinister", "Specter", "Spiral", "Stalker", "Stasis", "Subterfuge", "Terror",
			"Threnody", "Torment", "Torture", "Treachery", "Trepidation", "Tryst", "Twilight", "Unholy", "Vampire", "Vengeance",
			"Venom", "Vile", "Vortex", "Wailing", "Wasteland", "Whisper", "Wicked", "Wrath", "Wretched", "Zephyr"
		};

		public static string[] Level_LastWord = new string[98]
		{
			"Abyss", "Anomaly", "Apparition", "Ascent", "Ashes", "Banishment", "Barrow", "Bastion", "Beacon", "Burial",
			"Cascade", "Cataclysm", "Cavern", "Chasm", "Collapse", "Conundrum", "Corridor", "Corrupter", "Crevasse", "Crypt",
			"Cyst", "Darkness", "Death", "Delirium", "Demise", "Depth", "Descent", "Detritus", "Dread", "Eclipse",
			"Embrace", "Empire", "End", "Erosion", "Expanse", "Fissure", "Gallows", "Gloom", "Grave", "Halls",
			"Hollow", "Horror", "Inferno", "Labyrinth", "Lament", "Legacy", "Maw", "Maze", "Mirage", "Monolith",
			"Morass", "Morgue", "Nadir", "Necropolis", "Obelisk", "Oblivion", "Obscurity", "Obstruction", "Omen", "Pandemonium",
			"Paradigm", "Paradox", "Passage", "Phantasm", "Pit", "Portal", "Purgatory", "Quagmire", "Realm", "Reckoning",
			"Relic", "Requiem", "Rift", "Sanctuary", "Sarcophagus", "Scourge", "Sepulcher", "Shrine", "Spire", "Tomb",
			"Torment", "Trench", "Trove", "Tundra", "Undertow", "Underworld", "Vale", "Vault", "Veil", "Vestige",
			"Vortex", "Wasteland", "Whisper", "Womb", "Wraith", "Wreck", "Yawning", "Zenith"
		};

		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]
		{
			"Atrophying", "Bleeding", "Breaking", "Caving", "Collapsing", "Corroding", "Crumbling", "Decaying", "Declining", "Degenerating",
			"Depleting", "Despairing", "Deteriorating", "Diminishing", "Disintegrating", "Dissipating", "Dissolving", "Draining", "Drowning", "Eroding",
			"Fading", "Fading", "Floundering", "Fraying", "Fumbling", "Languishing", "Moldering", "Perishing", "Ravaging", "Regressing",
			"Sinking", "Slipping", "Struggling", "Succumbing", "Suffering", "Wasting", "Weakening", "Wilting", "Withering", "Wrecking"
		};

		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"
		};

		public static List<string> NewLevelNamesPack()
		{
			List<string> collection = new List<string>(NounsLevel);
			List<string> list = new List<string>(Level_FirstWord);
			List<string> collection2 = new List<string>(Level_LastWord);
			List<string> list2 = new List<string>(VerbsPresentParticiple);
			List<string> list3 = new List<string>();
			for (int i = 0; i < 30; i++)
			{
				if (Generator.Flip(0.15))
				{
					string item = Generator.Draw(collection);
					list3.Add(item);
				}
				else
				{
					string text = Generator.Draw(Generator.Flip(0.3) ? list2 : list);
					string text2 = Generator.Draw(collection2);
					list3.Add(text + " " + text2);
				}
			}
			return list3;
		}
	}
}
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 static BigPickupDistribution PowerCell_1 = new BigPickupDistribution
		{
			SpawnsPerZone = 1u,
			SpawnData = 
			{
				new ItemSpawn
				{
					Item = Item.PowerCell
				}
			}
		};

		public static BigPickupDistribution PowerCell_2 = new BigPickupDistribution
		{
			SpawnsPerZone = 2u,
			SpawnData = 
			{
				new ItemSpawn
				{
					Item = Item.PowerCell
				}
			}
		};

		public static BigPickupDistribution PowerCell_3 = new BigPickupDistribution
		{
			SpawnsPerZone = 3u,
			SpawnData = 
			{
				new ItemSpawn
				{
					Item = Item.PowerCell
				}
			}
		};

		public static BigPickupDistribution PowerCell_4 = new BigPickupDistribution
		{
			SpawnsPerZone = 4u,
			SpawnData = 
			{
				new ItemSpawn
				{
					Item = Item.PowerCell
				}
			}
		};

		public static BigPickupDistribution PowerCell_5 = new BigPickupDistribution
		{
			SpawnsPerZone = 5u,
			SpawnData = 
			{
				new ItemSpawn
				{
					Item = Item.PowerCell
				}
			}
		};

		public new static void SaveStatic()
		{
			Bins.BigPickupDistributions.AddBlock(FogTurbine);
			Bins.BigPickupDistributions.AddBlock(PowerCell_1);
			Bins.BigPickupDistributions.AddBlock(PowerCell_2);
			Bins.BigPickupDistributions.AddBlock(PowerCell_3);
			Bins.BigPickupDistributions.AddBlock(PowerCell_4);
			Bins.BigPickupDistributions.AddBlock(PowerCell_5);
		}

		[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 LazyBlocksBin<ChainedPuzzle> ChainedPuzzles { get; private set; } = new LazyBlocksBin<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<Text> Texts { get; private set; } = new BlocksBin<Text>();


		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()
		{
			Text.Setup();
			DataBlock.SaveStatic();
			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");
			Texts.Save("Text");
			WardenObjectives.Save("WardenObjective");
			WavePopulations.Save("SurvivalWavePopulation");
			WaveSettings.Save("SurvivalWaveSettings");
		}
	}
	public class BlocksBin<T> where T : DataBlock
	{
		internal 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 LazyBlocksBin<T> : BlocksBin<T> where T : DataBlock
	{
		public new void AddBlock(T? block)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			if (block == null)
			{
				return;
			}
			if (base.Blocks.Contains(block))
			{
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(27, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Already got ChainedPuzzle: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<T>(block);
				}
				logger.LogWarning(val);
			}
			else
			{
				base.Blocks.Add(block);
				if (block.PersistentId != 0)
				{
					persistentIds.Add(block.PersistentId);
					base.LastPersistentId = Math.Max(base.LastPersistentId, block.PersistentId);
				}
			}
		}

		public bool Contains(T? block)
		{
			return base.Blocks.Contains(block);
		}

		public T? GetBlock(T? block)
		{
			T block2 = block;
			return base.Blocks.Find((T b) => (DataBlock?)b == (DataBlock?)block2);
		}

		public void Persist()
		{
			foreach (T item in base.Blocks.Where((T block) => block.PersistentId == 0))
			{
				item.PersistentId = Generator.GetPersistentId();
				persistentIds.Add(item.PersistentId);
				base.LastPersistentId = Math.Max(base.LastPersistentId, item.PersistentId);
			}
		}

		public new void Save(string name)
		{
			Persist();
			base.Save(name);
		}
	}
	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 static ConsumableDistribution Reactor_FogRepellers = new ConsumableDistribution
		{
			SpawnsPerZone = 10u,
			SpawnData = Collections.Flatten<ItemSpawn>(ItemSpawn.GlowSticks(2.0), new List<ItemSpawn>
			{
				new ItemSpawn
				{
					Item = Item.FogRepeller,
					Weight = 8.0
				}
			})
		};

		public new static void SaveStatic()
		{
			Bins.ConsumableDistributions.AddBlock(Baseline);
			Bins.ConsumableDistributions.AddBlock(Baseline_FogRepellers);
			Bins.ConsumableDistributions.AddBlock(Reactor_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 = 100,
		Huge = 125
	}
	public class CoverageMinMax
	{
		private static List<double> Sizes = new List<double> { 25.0, 35.0, 50.0, 75.0, 100.0, 125.0 };

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

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

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

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

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

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

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

		private static List<(double, (double, double))> NormalSizes = new List<(double, (double, double))>
		{
			(0.25, (10.0, 10.0)),
			(0.45, (10.0, 20.0)),
			(0.85, (20.0, 20.0)),
			(1.0, (20.0, 32.0)),
			(1.0, (32.0, 32.0)),
			(1.0, (32.0, 42.0)),
			(1.0, (42.0, 42.0)),
			(0.55, (42.0, 64.0)),
			(0.45, (64.0, 64.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()
		{
			var (min, max) = Generator.Select(NormalSizes);
			return new CoverageMinMax
			{
				Min = min,
				Max = max
			};
		}

		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 BlockName
		{
			get
			{
				return $"{PersistentId}_{Name}";
			}
			private set
			{
			}
		}

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

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


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

		public static void Setup<TGameData, TBlock>(BlocksBin<TBlock> bin, string filename) where TGameData : TBlock where TBlock : DataBlock
		{
			JObject obj = JObject.Parse(File.ReadAllText(Path.Combine(Path.Combine(Paths.PluginPath, "the_tavern-AutogenRundown"), "GameData_" + filename + "DataBlock_bin.json")));
			if (((obj != null) ? obj["Blocks"] : null) == null)
			{
				throw new Exception("Failed to get 'Blocks' property");
			}
			foreach (TGameData item in obj["Blocks"].ToObject<List<TGameData>>() ?? throw new Exception("Failed to parse " + filename))
			{
				bin.AddBlock((TBlock)(DataBlock)item);
			}
		}

		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
	{
		[JsonIgnore]
		public int Points { get; set; } = 25;


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


		public EnemyGroupType GroupType { get; set; }

		public uint Difficulty { get; set; }

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


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

		private const 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,
			Tags = new Tags("scout")
		};

		public static EnemySpawningData ScoutCharger = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Scout,
			Difficulty = 3u,
			Tags = new Tags("scout")
		};

		public static EnemySpawningData ScoutShadow = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Scout,
			Difficulty = 4u,
			Tags = new Tags("scout")
		};

		public static EnemySpawningData ScoutNightmare = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Scout,
			Difficulty = 6u,
			Tags = new Tags("scout")
		};

		public static EnemySpawningData ScoutZoomer = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Scout,
			Difficulty = 5u,
			Tags = new Tags("scout")
		};

		public static EnemySpawningData Mother = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 36u,
			Tags = new Tags("boss")
		};

		public static EnemySpawningData PMother = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 37u,
			Tags = new Tags("boss")
		};

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

		public static EnemySpawningData Tank = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 29u,
			Tags = new Tags("boss")
		};

		public static EnemySpawningData TankPotato = new EnemySpawningData
		{
			GroupType = EnemyGroupType.Hibernate,
			Difficulty = 62u,
			Tags = new Tags("boss")
		};

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

		public EnemySpawningData()
		{
		}
	}
	public enum Complex
	{
		Mining = 1,
		Tech = 3,
		Service = 53
	}
	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,
			DensityHeightRange = 10.0,
			FogColor = new Color
			{
				Red = 1.4,
				Green = 1.4,
				Blue = 1.4,
				Alpha = 0.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 Intel
	{
		public const string Info = ":://<color=cyan>INFO</color>";

		public const string Warning = ":://WARNING";

		public const string Error = ":://ERROR";

		public string Zone(int number)
		{
			return $"<color=orange>ZONE {number}</color>";
		}
	}
	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.Select(new List<(double, Complex)>
		{
			(1.0, Complex.Mining),
			(1.0, Complex.Tech),
			(0.7, Complex.Service)
		});


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


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

		[JsonIgnore]
		public List<RelativeDirection> RelativeDirections { get; set; } = new List<RelativeDirection>
		{
			RelativeDirection.Global_Forward,
			RelativeDirection.Global_Left,
			RelativeDirection.Global_Right,
			RelativeDirection.Global_Backward
		};


		[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 uint Description { get; set; }

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


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

		[JsonIgnore]
		public string? Prefix { get; set; }

		public JObject Descriptive => new JObject
		{
			["Prefix"] = JToken.op_Implicit(IsTest ? "TEST" : (Prefix ?? 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(ScoutWaveSettings.PersistentId),
			["ScoutWavePopulation"] = JToken.op_Implicit(ScoutWavePopulation.PersistentId),
			["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;


		[JsonProperty("SpecialOverrideData")]
		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)
		};

		[JsonIgnore]
		public WavePopulation ScoutWavePopulation { get; set; } = WavePopulation.Baseline;


		[JsonIgnore]
		public WaveSettings ScoutWaveSettings { get; set; } = WaveSettings.Scout_Easy;


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

		public Level(string tier)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Expected O, but got Unknown
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_016d: Expected O, but got Unknown
			Tier = tier;
			Settings = new LevelSettings(tier);
		}

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

		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), 
			};
		}

		private 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();
			buildDirector.Complex = Complex;
			buildDirector.Settings = Settings;
			WardenObjective wardenObjective = WardenObjective.PreBuild(buildDirector, this);
			RelativeDirection direction = RelativeDirection.Global_Forward;
			switch (bulkhead)
			{
			case Bulkhead.Main:
			{
				direction = Generator.Draw(RelativeDirections);
				ZoneExpansion forward = direction.Forward;
				RelativeDirection relativeDirection = default(RelativeDirection);
				switch (forward)
				{
				case ZoneExpansion.Forward:
					relativeDirection = RelativeDirection.Global_Backward;
					break;
				case ZoneExpansion.Left:
					relativeDirection = RelativeDirection.Global_Right;
					break;
				case ZoneExpansion.Right:
					relativeDirection = RelativeDirection.Global_Left;
					break;
				case ZoneExpansion.Backward:
					relativeDirection = RelativeDirection.Global_Forward;
					break;
				default:
					global::<PrivateImplementationDetails>.ThrowSwitchExpressionException(forward);
					break;
				}
				RelativeDirection item = relativeDirection;
				RelativeDirections.Remove(item);
				break;
			}
			case Bulkhead.Extreme:
			case Bulkhead.Overload:
				direction = Generator.Draw(RelativeDirections);
				break;
			}
			LevelLayout levelLayout = LevelLayout.Build(this, buildDirector, wardenObjective, direction);
			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_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_0312: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Expected O, but got Unknown
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0451: 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();
			Bulkhead bulkhead = Generator.Select(new List<(double, Bulkhead)>
			{
				(0.25, Bulkhead.Main),
				(0.4, Bulkhead.Main | Bulkhead.Extreme),
				(0.2, Bulkhead.Main | Bulkhead.Overload),
				(0.15, Bulkhead.PrisonerEfficiency)
			});
			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(24, 4, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" (");
				((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Complex>(level.Complex);
				((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
					};
				}
			}
			level.GetObjective(Bulkhead.Main).PostBuild(level.MainDirector, level);
			if (bulkhead.HasFlag(Bulkhead.Extreme) && level.GetObjective(Bulkhead.Extreme) != null)
			{
				level.GetObjective(Bulkhead.Extreme).PostBuild(level.SecondaryDirector, level);
			}
			if (bulkhead.HasFlag(Bulkhead.Overload) && level.GetObjective(Bulkhead.Overload) != null)
			{
				level.GetObjective(Bulkhead.Overload).PostBuild(level.OverloadDirector, level);
			}
			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 RelativeDirection direction;

		[JsonIgnore]
		private LayoutPlanner planner;

		[JsonIgnore]
		private LevelSettings settings;

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

		public void RollAlarms(ICollection<(double, int, ChainedPuzzle)> puzzlePack, ICollection<(double, int, WavePopulation)> wavePopulationPack, ICollection<(double, int, WaveSettings)> waveSettingsPack)
		{
			foreach (Zone zone in Zones)
			{
				zone.RollAlarms(puzzlePack, wavePopulationPack, waveSettingsPack);
			}
		}

		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_Shado