using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
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.Custom.AdvancedWardenObjective;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization.Abilities;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization.Models;
using AutogenRundown.DataBlocks.Custom.ExtraObjectiveSetup;
using AutogenRundown.DataBlocks.Custom.ExtraObjectiveSetup.ExtensionSecuritySensor;
using AutogenRundown.DataBlocks.Dimensions;
using AutogenRundown.DataBlocks.Enemies;
using AutogenRundown.DataBlocks.Enums;
using AutogenRundown.DataBlocks.Items;
using AutogenRundown.DataBlocks.Levels;
using AutogenRundown.DataBlocks.Light;
using AutogenRundown.DataBlocks.Objectives;
using AutogenRundown.DataBlocks.Objectives.Reactor;
using AutogenRundown.DataBlocks.Terminals;
using AutogenRundown.DataBlocks.ZoneData;
using AutogenRundown.DataBlocks.Zones;
using AutogenRundown.Extensions;
using AutogenRundown.GeneratorData;
using AutogenRundown.Patches;
using AutogenRundown.PeerMods;
using AutogenRundown.Utils;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using CellMenu;
using HarmonyLib;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using TMPro;
using UnityEngine;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.NamingConventions;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("AutogenRundown")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[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; }

		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;


		[Obsolete("Prefer specifying the number of zones in each objective layout")]
		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,
				WardenObjectiveType.TimedTerminalSequence
			};
			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;
		}

		[Obsolete("Prefer specifying the number of zones in each objective layout")]
		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, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/AssetPrefabs/Complex/Mining/Geomorphs/geo_32x32_elevator_shaft_dig_site_04.prefab",
				SubComplex = SubComplex.DigSite
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/AssetPrefabs/Complex/Mining/Geomorphs/Refinery/geo_64x64_mining_refinery_X_HA_04_test.prefab",
				SubComplex = SubComplex.Storage
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_mining_dig_site_t_dak_01.prefab",
				SubComplex = SubComplex.DigSite
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_dig_site_i_dak_01.prefab",
				SubComplex = SubComplex.DigSite
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Exit_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_dig_site_exit_dak_01.prefab",
				SubComplex = SubComplex.DigSite
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_dig_site_dead_end_dak_01.prefab",
				SubComplex = SubComplex.DigSite
			});
			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.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Bundles/RLC_Mining/geo_64x64_mining_digsite_dead_end_RLC_01.prefab",
				SubComplex = SubComplex.DigSite
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Exit_1x1", new Prefab
			{
				Asset = "Assets/Bundles/RLC_Mining/geo_64x64_mining_storage_exit_hub_RLC_01.prefab",
				SubComplex = SubComplex.Storage
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Bundles/RLC_Mining/geo_64x64_mining_storage_I_RLC_01.prefab",
				SubComplex = SubComplex.Storage
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Bundles/RLC_Mining/geo_64x64_mining_refinery_X_RLC_01.prefab",
				SubComplex = SubComplex.Refinery
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Bundles/RLC_Mining/geo_64x64_mining_refinery_I_RLC_01.prefab",
				SubComplex = SubComplex.Refinery
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Bundles/RLC_Mining/geo_64x64_mining_refinery_portal_I_RLC_01.prefab",
				SubComplex = SubComplex.Refinery
			});
			complexResourceSet.AddPrefab(Complex.Mining, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Bundles/RLC_Mining/geo_64x64_mining_reactor_RLC_01.prefab",
				SubComplex = SubComplex.All
			});
			complexResourceSet.AddPrefab(Complex.Tech, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_tech_data_center_I_tile_DS_1.prefab",
				SubComplex = SubComplex.DataCenter
			});
			complexResourceSet.AddPrefab(Complex.Tech, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_tech_data_center_hub_DS_01.prefab",
				SubComplex = SubComplex.DataCenter
			});
			complexResourceSet.AddPrefab(Complex.Tech, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_data_center_reactor_DS_01.prefab",
				SubComplex = SubComplex.DataCenter
			});
			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/Bundles/RLC_Tech/geo_64x64_tech_lab_I_RLC_01.prefab",
				SubComplex = SubComplex.Lab
			});
			complexResourceSet.AddPrefab(Complex.Tech, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Bundles/RLC_Tech/geo_64x64_tech_lab_Hub_RLC_01.prefab",
				SubComplex = SubComplex.Lab
			});
			complexResourceSet.AddPrefab(Complex.Tech, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Bundles/RLC_Tech/geo_64x64_tech_data_center_hub_JG_RLC_02_v3.prefab",
				SubComplex = SubComplex.DataCenter
			});
			complexResourceSet.AddPrefab(Complex.Tech, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/Bundles/RLC_Tech/geo_64x64_tech_datacenter_I_RLC_01.prefab",
				SubComplex = SubComplex.DataCenter
			});
			complexResourceSet.AddPrefab(Complex.Service, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/AssetPrefabs/Complex/Service/Geomorphs/Maintenance/geo_64x64_service_floodways_dead_end_HA_02.prefab",
				SubComplex = SubComplex.Floodways
			});
			complexResourceSet.AddPrefab(Complex.Service, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/AssetPrefabs/Complex/Service/Geomorphs/Maintenance/geo_64x64_service_floodways_hub_HA_03_V2.prefab",
				SubComplex = SubComplex.Floodways
			});
			complexResourceSet.AddPrefab(Complex.Service, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_service_floodways_hub_DS_01.prefab",
				SubComplex = SubComplex.Floodways
			});
			complexResourceSet.AddPrefab(Complex.Service, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_service_floodways_boss_hub_DS_01.prefab",
				SubComplex = SubComplex.Floodways
			});
			complexResourceSet.AddPrefab(Complex.Service, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_service_floodways_hub_ds_02.prefab",
				SubComplex = SubComplex.Floodways
			});
			complexResourceSet.AddPrefab(Complex.Service, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_service_floodways_reactor_ds_01.prefab",
				SubComplex = SubComplex.Floodways
			});
			complexResourceSet.AddPrefab(Complex.Service, "CustomGeomorphs_Objective_1x1", new Prefab
			{
				Asset = "Assets/geo_64x64_service_floodways_i_bridge_ds_01.prefab",
				SubComplex = SubComplex.Floodways
			});
			complexResourceSet.AddPrefab(Complex.Service, "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,
		Enemy,
		EnemyGroup,
		WavePopulation,
		WaveSettings
	}
	public static class Generator
	{
		public interface ISelectable
		{
			double Weight { get; set; }
		}

		public static uint pid = 100000u;

		private static uint enemyPid = 70u;

		private static uint enemyGroupPid = 80u;

		private static uint wavePopulationPid = 200u;

		private static uint waveSettingsPid = 1u;

		public static int MonthNumber { get; set; } = -1;


		public static int WeekNumber { get; set; } = -1;


		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 void SelectRun(ICollection<(double, Action)> collection)
		{
			double num = collection.Sum<(double, Action)>(((double, Action) x) => x.Item1);
			double num2 = Random.NextDouble() * num;
			double num3 = 0.0;
			foreach (var item3 in collection)
			{
				double item = item3.Item1;
				Action item2 = item3.Item2;
				num3 += item;
				if (!(num2 > num3))
				{
					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.Enemy:
				return enemyPid++;
			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 SetMonthSeed()
		{
			DateTime utcNow = DateTime.UtcNow;
			TimeZoneInfo destinationTimeZone = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
			DateTime dateTime = TimeZoneInfo.ConvertTimeFromUtc(utcNow, destinationTimeZone);
			string seed = dateTime.ToString("yyyy_MM");
			string text = dateTime.ToString("MMMM");
			Seed = seed;
			DisplaySeed = "<color=orange>" + text + "</color>";
			MonthNumber = dateTime.Month;
		}

		public static void SetWeeklySeed()
		{
			DateTime utcNow = DateTime.UtcNow;
			TimeZoneInfo destinationTimeZone = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
			DateTime dateTime = TimeZoneInfo.ConvertTimeFromUtc(utcNow, destinationTimeZone);
			int weekOfYear = CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(dateTime, CalendarWeekRule.FirstFullWeek, DayOfWeek.Tuesday);
			string seed = $"{dateTime:yyyy}_{weekOfYear}";
			string text = $"Week {weekOfYear}";
			Seed = seed;
			DisplaySeed = "<color=orange>" + text + "</color>";
			WeekNumber = weekOfYear;
		}

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

		public static void ReadOrSetSeed(string seed = "")
		{
			if (seed != "")
			{
				Seed = seed;
				DisplaySeed = "<color=orange>" + seed + "</color>";
			}
			else
			{
				GenerateTimeSeed();
			}
		}

		public static void AdvanceSequence(int rounds)
		{
			while (rounds-- > 0)
			{
				Random.Next();
			}
		}

		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;
		}
	}
	public class LocalProgression
	{
		public static void WriteConfig()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			new JsonSerializer().Formatting = (Formatting)1;
			int revision = CellBuildData.GetRevision();
			string text = Path.Combine(Paths.BepInExRootPath, "GameData", $"{revision}", "Custom", "LocalProgressionConfig");
			string path = Path.Combine(text, "ProgressionConfig.json");
			Directory.CreateDirectory(text);
			using StreamWriter streamWriter = new StreamWriter(path);
			streamWriter.Write($"{{\n    \"Configs\": [\n        {{\n            \"RundownID\": {Rundown.R_Daily},\n            \"EnableNoBoosterUsedProgressionForRundown\": true,\n            \"AlwaysShowIcon\": true,\n            \"Expeditions\": []\n        }},\n        {{\n            \"RundownID\": {Rundown.R_Weekly},\n            \"EnableNoBoosterUsedProgressionForRundown\": true,\n            \"AlwaysShowIcon\": true,\n            \"Expeditions\": []\n        }},\n        {{\n            \"RundownID\": {Rundown.R_Monthly},\n            \"EnableNoBoosterUsedProgressionForRundown\": true,\n            \"AlwaysShowIcon\": true,\n            \"Expeditions\": []\n        }}\n    ]\n}}");
			streamWriter.Flush();
		}
	}
	public static class Peers
	{
		private static List<Mod> Mods { get; set; } = new List<Mod>();


		public static void Init()
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			try
			{
				string text = File.ReadAllText(Path.Combine(Paths.BepInExRootPath, "..", "mods.yml"));
				Mods = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).WithNamingConvention(CamelCaseNamingConvention.Instance).Build().Deserialize<List<Mod>>(text);
			}
			catch (FileNotFoundException)
			{
				Plugin.Logger.LogWarning((object)"Peers.Init(): Could not find mods.yml");
			}
		}

		public static bool HasMod(string name)
		{
			string name2 = name;
			return Mods.Any((Mod mod) => mod.Name == name2 && mod.Enabled);
		}

		public static void Configure()
		{
			LocalProgression.WriteConfig();
			Arsenality.Configure();
		}
	}
	[BepInPlugin("000-the_tavern-AutogenRundown", "AutogenRundown", "0.58.1")]
	[BepInProcess("GTFO.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		public const string Version = "0.58.1";

		public const string Name = "the_tavern-AutogenRundown";

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


		public override void Load()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_003a: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0066: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Expected O, but got Unknown
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BasePlugin)this).Log;
			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);
			if (val2.Value)
			{
				Peers.Init();
				RundownFactory.Build(val.Value);
				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("the_tavern-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 Rundown BuildRundown(Rundown newRundown, bool withFixed = true, bool withUnlocks = true)
		{
			Rundown rundown = Rundown.Build(newRundown);
			List<string> collection = Words.NewLevelNamesPack();
			for (int i = 0; i < rundown.TierA_Count; i++)
			{
				int num = 1;
				if (rundown.BuildSeedPool.Count > 0)
				{
					num = rundown.BuildSeedPool[0];
					rundown.BuildSeedPool.RemoveAt(0);
					Generator.AdvanceSequence(num);
				}
				Level level = Level.Build(new Level("A")
				{
					Name = Generator.Draw(collection),
					Index = i + 1,
					BuildSeed = num
				});
				rundown.AddLevel(level);
			}
			for (int j = 0; j < rundown.TierB_Count; j++)
			{
				int num2 = 1;
				if (rundown.BuildSeedPool.Count > 0)
				{
					num2 = rundown.BuildSeedPool[0];
					rundown.BuildSeedPool.RemoveAt(0);
					Generator.AdvanceSequence(num2);
				}
				Level level2 = Level.Build(new Level("B")
				{
					Name = Generator.Draw(collection),
					Index = j + 1,
					BuildSeed = num2
				});
				rundown.AddLevel(level2);
			}
			for (int k = 0; k < rundown.TierC_Count; k++)
			{
				int num3 = 1;
				if (rundown.BuildSeedPool.Count > 0)
				{
					num3 = rundown.BuildSeedPool[0];
					rundown.BuildSeedPool.RemoveAt(0);
					Generator.AdvanceSequence(num3);
				}
				Level level3 = Level.Build(new Level("C")
				{
					Name = Generator.Draw(collection),
					Index = k + 1,
					BuildSeed = num3
				});
				rundown.AddLevel(level3);
			}
			if (withFixed)
			{
				WardenObjectiveType wardenObjectiveType = WardenObjectiveType.Survival;
				BuildDirector buildDirector = new BuildDirector
				{
					Bulkhead = Bulkhead.Main,
					Complex = Complex.Tech,
					Tier = "B",
					Objective = wardenObjectiveType
				};
				buildDirector.GenPoints();
				BuildDirector buildDirector2 = new BuildDirector
				{
					Bulkhead = Bulkhead.Extreme,
					Complex = Complex.Tech,
					Complexity = Complexity.Low,
					Tier = "B",
					Objective = WardenObjectiveType.SpecialTerminalCommand
				};
				buildDirector2.GenPoints();
				LevelSettings settings = new LevelSettings("B");
				AutogenRundown.DataBlocks.Text text = new AutogenRundown.DataBlocks.Text(DescriptionHeader(wardenObjectiveType) + WardenObjective.GenLevelDescription(wardenObjectiveType));
				Level level4 = Level.Build(new Level("B")
				{
					Prefix = "<color=orange>X</color><color=#444444>:</color>B",
					Description = text.PersistentId,
					Complex = Complex.Tech,
					MainDirector = buildDirector,
					SecondaryDirector = buildDirector2,
					Settings = settings,
					Index = rundown.TierB_Count
				});
				rundown.AddLevel(level4);
			}
			for (int l = 1; l < rundown.TierD_Count + 1; l++)
			{
				int num4 = 1;
				if (rundown.BuildSeedPool.Count > 0)
				{
					num4 = rundown.BuildSeedPool[0];
					rundown.BuildSeedPool.RemoveAt(0);
					Generator.AdvanceSequence(num4);
				}
				Level level5 = Level.Build(new Level("D")
				{
					Name = Generator.Draw(collection),
					Index = l + 1,
					BuildSeed = num4
				});
				rundown.AddLevel(level5);
			}
			for (int m = 0; m < rundown.TierE_Count; m++)
			{
				int num5 = 1;
				if (rundown.BuildSeedPool.Count > 0)
				{
					num5 = rundown.BuildSeedPool[0];
					rundown.BuildSeedPool.RemoveAt(0);
					Generator.AdvanceSequence(num5);
				}
				Level level6 = Level.Build(new Level("E")
				{
					Name = Generator.Draw(collection),
					Index = m + 1,
					BuildSeed = num5
				});
				rundown.AddLevel(level6);
			}
			if (!withUnlocks)
			{
				return rundown;
			}
			rundown.UseTierUnlockRequirements = true;
			rundown.ReqToReachTierB.MainSectors = Math.Max(1, rundown.TierA.Count - 1);
			rundown.ReqToReachTierC.MainSectors = Math.Max(0, rundown.ReqToReachTierB.MainSectors + rundown.TierB.Count - 1);
			rundown.ReqToReachTierD.MainSectors = Math.Max(0, rundown.ReqToReachTierC.MainSectors + rundown.TierC.Count - 1);
			rundown.ReqToReachTierE.MainSectors = Math.Max(0, rundown.ReqToReachTierD.MainSectors + rundown.TierD.Count - 1);
			return rundown;
		}

		public static Rundown BuildMonthlyRundown(Rundown newRundown)
		{
			Rundown rundown = Rundown.Build(newRundown);
			List<string> collection = Words.NewLevelNamesPack();
			Dictionary<string, List<List<int>>> dictionary = new Dictionary<string, List<List<int>>>();
			dictionary.Add("2025_04", new List<List<int>>
			{
				new List<int> { 2, 1 },
				new List<int> { 1, 1, 1 },
				new List<int> { 1, 1, 1, 1 },
				new List<int> { 2, 1, 2, 1 },
				new List<int> { 1, 1 }
			});
			dictionary.TryGetValue(Generator.Seed, out var value);
			if (value == null)
			{
				value = new List<List<int>>
				{
					new List<int> { 2, 1 },
					new List<int> { 1, 1, 1 },
					new List<int> { 1, 1, 1, 1 },
					new List<int> { 2, 1, 1, 1 },
					new List<int> { 1, 1 }
				};
			}
			List<(double, int, WardenObjectiveType)> collection2 = new List<(double, int, WardenObjectiveType)>
			{
				(1.0, 3, WardenObjectiveType.HsuFindSample),
				(1.0, 3, WardenObjectiveType.ReactorStartup),
				(1.0, 3, WardenObjectiveType.ReactorShutdown),
				(1.0, 2, WardenObjectiveType.GatherSmallItems),
				(1.0, 2, WardenObjectiveType.ClearPath),
				(0.7, 1, WardenObjectiveType.SpecialTerminalCommand),
				(1.0, 3, WardenObjectiveType.RetrieveBigItems),
				(1.0, 2, WardenObjectiveType.PowerCellDistribution),
				(1.0, 3, WardenObjectiveType.TerminalUplink),
				(1.0, 3, WardenObjectiveType.Survival),
				(1.0, 2, WardenObjectiveType.TimedTerminalSequence)
			};
			List<(double, int, Complex)> collection3 = new List<(double, int, Complex)>
			{
				(1.0, 10, Complex.Mining),
				(1.0, 10, Complex.Tech),
				(0.8, 10, Complex.Service)
			};
			rundown.TierA_Count = value[0].Count;
			rundown.TierB_Count = value[1].Count;
			rundown.TierC_Count = value[2].Count;
			rundown.TierD_Count = value[3].Count;
			rundown.TierE_Count = value[4].Count;
			for (int i = 0; i < rundown.TierA_Count; i++)
			{
				int num = value[0][i];
				Generator.AdvanceSequence(num);
				Complex complex = Generator.DrawSelect(collection3);
				WardenObjectiveType objective = Generator.DrawSelect(collection2);
				BuildDirector mainDirector = new BuildDirector
				{
					Bulkhead = Bulkhead.Main,
					Complex = complex,
					Tier = "A",
					Objective = objective
				};
				Level level = Level.Build(new Level("A")
				{
					Name = Generator.Draw(collection),
					Index = i + 1,
					Complex = complex,
					MainDirector = mainDirector,
					BuildSeed = num
				});
				rundown.AddLevel(level);
			}
			for (int j = 0; j < rundown.TierB_Count; j++)
			{
				int num2 = value[1][j];
				Generator.AdvanceSequence(num2);
				Complex complex2 = Generator.DrawSelect(collection3);
				WardenObjectiveType objective2 = Generator.DrawSelect(collection2);
				BuildDirector mainDirector2 = new BuildDirector
				{
					Bulkhead = Bulkhead.Main,
					Complex = complex2,
					Tier = "B",
					Objective = objective2
				};
				Level level2 = Level.Build(new Level("B")
				{
					Name = Generator.Draw(collection),
					Index = j + 1,
					Complex = complex2,
					MainDirector = mainDirector2,
					BuildSeed = num2
				});
				rundown.AddLevel(level2);
			}
			for (int k = 0; k < rundown.TierC_Count; k++)
			{
				int num3 = value[2][k];
				Generator.AdvanceSequence(num3);
				Complex complex3 = Generator.DrawSelect(collection3);
				WardenObjectiveType objective3 = Generator.DrawSelect(collection2);
				BuildDirector mainDirector3 = new BuildDirector
				{
					Bulkhead = Bulkhead.Main,
					Complex = complex3,
					Tier = "C",
					Objective = objective3
				};
				Level level3 = Level.Build(new Level("C")
				{
					Name = Generator.Draw(collection),
					Index = k + 1,
					Complex = complex3,
					MainDirector = mainDirector3,
					BuildSeed = num3
				});
				rundown.AddLevel(level3);
			}
			for (int l = 0; l < rundown.TierD_Count; l++)
			{
				int num4 = value[3][l];
				Generator.AdvanceSequence(num4);
				Complex complex4 = Generator.DrawSelect(collection3);
				WardenObjectiveType objective4 = Generator.DrawSelect(collection2);
				BuildDirector mainDirector4 = new BuildDirector
				{
					Bulkhead = Bulkhead.Main,
					Complex = complex4,
					Tier = "D",
					Objective = objective4
				};
				Level level4 = Level.Build(new Level("D")
				{
					Name = Generator.Draw(collection),
					Index = l + 1,
					Complex = complex4,
					MainDirector = mainDirector4,
					BuildSeed = num4
				});
				rundown.AddLevel(level4);
			}
			for (int m = 0; m < rundown.TierE_Count; m++)
			{
				int num5 = value[4][m];
				Generator.AdvanceSequence(num5);
				Complex complex5 = Generator.DrawSelect(collection3);
				WardenObjectiveType objective5 = Generator.DrawSelect(collection2);
				BuildDirector mainDirector5 = new BuildDirector
				{
					Bulkhead = Bulkhead.Main,
					Complex = complex5,
					Tier = "E",
					Objective = objective5
				};
				Level level5 = Level.Build(new Level("E")
				{
					Name = Generator.Draw(collection),
					Index = m + 1,
					Complex = complex5,
					MainDirector = mainDirector5,
					BuildSeed = num5
				});
				rundown.AddLevel(level5);
			}
			rundown.UseTierUnlockRequirements = true;
			rundown.ReqToReachTierB.MainSectors = Math.Max(1, rundown.TierA.Count - 1);
			rundown.ReqToReachTierC.MainSectors = Math.Max(0, rundown.ReqToReachTierB.MainSectors + rundown.TierB.Count - 1);
			rundown.ReqToReachTierD.MainSectors = Math.Max(0, rundown.ReqToReachTierC.MainSectors + rundown.TierC.Count - 1);
			rundown.ReqToReachTierE.MainSectors = Math.Max(0, rundown.ReqToReachTierD.MainSectors + rundown.TierD.Count - 1);
			rundown.VisualsETier = Color.MenuVisuals_MonthlyE;
			return rundown;
		}

		public static void Build(string dailySeed)
		{
			Bins.Setup();
			ComplexResourceSet.Setup();
			LayoutDefinitions.Setup();
			GameSetup gameSetup = new GameSetup
			{
				PersistentId = 1u,
				Name = "Default"
			};
			Generator.SetMonthSeed();
			Generator.Reload();
			string text = Words.RundownNameMonthly();
			Rundown block = BuildMonthlyRundown(new Rundown
			{
				PersistentId = Rundown.R_Monthly,
				Title = (text.ToUpper() ?? ""),
				StoryTitle = "<color=green>RND://</color>MONTHLY " + Generator.DisplaySeed + "\r\nTITLE: " + text.ToUpper()
			});
			Bins.Rundowns.AddBlock(block);
			Generator.SetWeeklySeed();
			Generator.Reload();
			string text2 = Generator.Pick(Words.Adjectives) + " " + Generator.Pick(Words.NounsRundown);
			bool withUnlocks = true;
			Rundown block2 = BuildRundown(new Rundown
			{
				PersistentId = Rundown.R_Weekly,
				Title = (text2.ToUpper() ?? ""),
				StoryTitle = "<color=green>RND://</color>WEEKLY " + Generator.DisplaySeed + "\r\nTITLE: " + text2.ToUpper()
			}, withFixed: false, withUnlocks);
			Bins.Rundowns.AddBlock(block2);
			Generator.ReadOrSetSeed(dailySeed);
			Generator.Reload();
			string text3 = Generator.Pick(Words.Adjectives) + " " + Generator.Pick(Words.NounsRundown);
			Rundown rundown = BuildRundown(new Rundown
			{
				PersistentId = Rundown.R_Daily,
				Title = (text3.ToUpper() ?? ""),
				StoryTitle = "<color=green>RND://</color>DAILY " + Generator.DisplaySeed + "\r\nTITLE: " + text3.ToUpper(),
				TierA_Count = 1,
				TierD_Count = 2,
				TierE_Count = Generator.Between(0, 2)
			}, withFixed: true, withUnlocks: false);
			rundown.VisualsETier = Color.MenuVisuals_DailyE;
			Bins.Rundowns.AddBlock(rundown);
			gameSetup.RundownIdsToLoad = new List<uint>
			{
				Rundown.R_Daily,
				Rundown.R_Monthly,
				Rundown.R_Weekly
			};
			Bins.GameSetups.AddBlock(gameSetup);
			Bins.Save();
			EnemyCustomization.Ability.Save();
			EnemyCustomization.Model.Save();
			Peers.Configure();
		}
	}
}
namespace AutogenRundown.Utils
{
	public class PriorityList
	{
	}
	public class Tags
	{
		private HashSet<string> tags = new HashSet<string>();

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

		public Tags(Tags previous)
		{
			tags = new HashSet<string>(previous.tags);
		}

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

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

		public Tags Extend(params string[] tags)
		{
			Tags tags2 = new Tags(this);
			foreach (string tag in tags)
			{
				tags2.Add(tag);
			}
			return tags2;
		}

		public override string ToString()
		{
			return "{" + string.Join(", ", tags.ToArray()) + "}";
		}
	}
}
namespace AutogenRundown.PeerMods
{
	public static class Arsenality
	{
		public static string MOD_NAME = "W33B-Arsenality";

		public static void Configure()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			if (Peers.HasMod(MOD_NAME))
			{
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(22, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Configuring peer mod: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(MOD_NAME);
				}
				logger.LogInfo(val);
				string pluginData = Path.Combine(Paths.BepInExRootPath, "plugins", MOD_NAME, "arsenality");
				int revision = CellBuildData.GetRevision();
				string gameData = Path.Combine(Paths.BepInExRootPath, "GameData", $"{revision}");
				Directory.CreateDirectory(Path.Combine(gameData, "Custom", "mccad00"));
				List<string> list = new List<string>();
				list.Add(Path.Combine("Custom", "mccad00", "GearPartTransform.json"));
				list.Add("GameData_ArchetypeDataBlock_bin.json");
				list.Add("GameData_GearCategoryDataBlock_bin.json");
				list.Add("GameData_GearMeleeHandlePartDataBlock_bin.json");
				list.Add("GameData_GearMeleeHeadPartDataBlock_bin.json");
				list.Add("GameData_GearMeleeNeckPartDataBlock_bin.json");
				list.Add("GameData_GearMeleePommelPartDataBlock_bin.json");
				list.Add("GameData_GearSightPartDataBlock_bin.json");
				list.Add("GameData_GearStockPartDataBlock_bin.json");
				list.Add("GameData_GearToolPayloadPartDataBlock_bin.json");
				list.Add("GameData_GearToolScreenPartDataBlock_bin.json");
				list.Add("GameData_GearToolTargetingPartDataBlock_bin.json");
				list.Add("GameData_MeleeAnimationSetDataBlock_bin.json");
				list.Add("GameData_MeleeArchetypeDataBlock_bin.json");
				list.Add("GameData_PlayerOfflineGearDataBlock_bin.json");
				list.ForEach(delegate(string path)
				{
					File.Copy(Path.Combine(pluginData, path), Path.Combine(gameData, path), overwrite: true);
				});
			}
		}
	}
	public class Mod
	{
		public int ManifestVersion { get; set; }

		public string Name { get; set; } = "";


		public string AuthorName { get; set; } = "";


		public string WebsiteUrl { get; set; } = "";


		public string DisplayName { get; set; } = "";


		public string Description { get; set; } = "";


		public string GameVersion { get; set; } = "";


		public string NetworkMode { get; set; } = "";


		public string PackageType { get; set; } = "";


		public string InstallMode { get; set; } = "";


		public long InstalledAtTime { get; set; }

		public List<string> Loaders { get; set; } = new List<string>();


		public List<string> Dependencies { get; set; } = new List<string>();


		public List<string> Incompatibilities { get; set; } = new List<string>();


		public List<string> OptionalDependencies { get; set; } = new List<string>();


		public VersionNumber VersionNumber { get; set; } = new VersionNumber();


		public bool Enabled { get; set; }

		public string Icon { get; set; } = "";

	}
	public class VersionNumber
	{
		public int Major { get; set; }

		public int Minor { get; set; }

		public int Patch { get; set; }
	}
}
namespace AutogenRundown.Patches
{
	[HarmonyPatch(typeof(CM_PageRundown_New), "OnExpeditionUpdated")]
	[HarmonyPatch(typeof(CM_PageRundown_New), "UpdateVanityItemUnlocks")]
	public class HideMenuItems
	{
		public static void Postfix(CM_PageRundown_New __instance)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			((Component)((Component)__instance).gameObject.transform.FindChild("MovingContent/Rundown/Button VanityItemDrops")).transform.localPosition = Vector3.up * 1000f;
			((Component)((Component)__instance).gameObject.transform.FindChild("MovingContent/Rundown/CM_PageRundown_VanityItemDropsNext")).transform.localPosition = Vector3.up * 2000f;
			((Component)((Component)__instance).gameObject.transform.FindChild("MovingContent/PasteAndJoinOnLobbyID/TutorialButton")).transform.localPosition = Vector3.left * 1000f;
			((Component)((Component)__instance).gameObject.transform.FindChild("MovingContent/PasteAndJoinOnLobbyID/Button Matchmake All")).transform.localPosition = Vector3.left * 1000f;
			((Component)((Component)__instance).gameObject.transform.FindChild("MovingContent/PasteAndJoinOnLobbyID/Button Rundown")).transform.localPosition = Vector3.left * 1000f;
			((Component)((Component)__instance).gameObject.transform.FindChild("MovingContent/PasteAndJoinOnLobbyID/Button Discord")).transform.localPosition = Vector3.left * 1000f;
			((Component)((Component)__instance).gameObject.transform.FindChild("MovingContent/PasteAndJoinOnLobbyID/ButtonGIF")).transform.localPosition = Vector3.left * 1000f;
		}
	}
	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);
				}
				switch (num)
				{
				case 0:
				{
					Rundown rundown3 = Bins.Rundowns.Find(Rundown.R_Daily);
					((TMP_Text)current.m_rundownText).text = "<size=70%><color=orange>DAILY</color><color=#444444>:</color> " + rundown3.Title + "</size>";
					break;
				}
				case 2:
				{
					Rundown rundown2 = Bins.Rundowns.Find(Rundown.R_Weekly);
					((TMP_Text)current.m_rundownText).text = $"<size=70%><color=green>WEEK #{Generator.WeekNumber}</color><color=#444444>:</color> {rundown2.Title}</size>";
					break;
				}
				case 1:
				{
					Rundown rundown = Bins.Rundowns.Find(Rundown.R_Monthly);
					((TMP_Text)current.m_rundownText).text = "<size=70%><color=#58fcee>MONTHLY</color><color=#444444>:</color> " + rundown.Title + "</size>";
					break;
				}
				}
				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.58.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;
		}

		public static string RundownNameMonthly()
		{
			int monthNumber = Generator.MonthNumber;
			switch (monthNumber)
			{
			case 1:
				return Generator.Pick(new List<string> { "Bleakburrow", "Mooncrypt", "Obsidian Grotto", "Chillmarrow", "Dampvault", "Umbral Cage", "Nightfissure", "Wraithclot", "Pale Labyrinth", "Blackmarsh" });
			case 2:
				return Generator.Pick(new List<string> { "Kovac's Shroud" });
			case 3:
				return Generator.Pick(new List<string> { "Sourgrove", "Waning Crypt", "Fetid Mine", "Gravewhisper", "Underrot", "Mireclaw", "Stillroot", "Gloomchoke", "Weeping Den" });
			case 4:
				return Generator.Pick(new List<string> { "Fogshard", "Drearnest", "Rotwood", "Witherspine", "Sporefen", "Tanglechasm", "Musty Hollow", "Duskreef", "Faint Maze", "Subtlecrag" });
			case 5:
				return Generator.Pick(new List<string> { "Fetid Thicket", "Wormblight", "Ashen Vault", "Goreburrow", "Briarcrypt", "Umbraspore", "Gullychill", "Soulchoke", "Darkfen", "Verdant Rot" });
			case 6:
				return Generator.Pick(new List<string> { "Cinderdeep", "Molded Pit", "Charfall", "Blightbarrow", "Grimwarren", "Gorecliff", "Dusthusk", "Marrow Reach", "Wraith Fane", "Hollow Thorn" });
			case 7:
				return Generator.Pick(new List<string> { "Bonechoke", "Rotcairn", "Dreggrotto", "Wraithknell", "Palechasm", "Dustwraith", "Husked Vale", "Bleakcyst", "Sunless Maw", "Murkspan" });
			case 8:
				return Generator.Pick(new List<string> { "Gorechoke", "Hollowrift", "Lurid Pit", "Cavernfrost", "Wormclot", "Faintcrawl", "Midnight Grotto", "Wraithscar", "Ember Hollow", "Sour Vault" });
			case 9:
				return Generator.Pick(new List<string> { "Underclaw", "Duskmarsh", "Cindercrypt", "Fallow Maw", "Grimspire", "Dregfen", "Shadowchoke", "Hazecrypt", "Briarchasm", "Twilight Burrow" });
			case 10:
				return Generator.Pick(new List<string> { "Wraithgrove", "Hollowthorn", "Ragged Depths", "Twilight Rift", "Musty Chasm", "Blackburrow", "Rotspire", "Moonfen", "Nightflare", "Molderclaw" });
			case 11:
				return Generator.Pick(new List<string> { "Frostwhisper", "Eboncrypt", "Shadowfen", "Dimthorn", "Quiet Grotto", "Waning Hollow", "Bleak Haze", "Underfissure", "Grey Rot", "Stygian Vault" });
			case 12:
				return Generator.Pick(new List<string> { "Night Shiver", "Bone Whisper", "Gloom Fane", "Cinderhusk", "Riftgloom", "Soul Hollow", "Midnightfen", "Plague Claw", "Umbral Crypt", "Bleakharrow" });
			default:
			{
				global::<PrivateImplementationDetails>.ThrowSwitchExpressionException(monthNumber);
				string result = default(string);
				return result;
			}
			}
		}
	}
}
namespace AutogenRundown.Extensions
{
	public static class Numeric
	{
		public static bool ApproxEqual(this double a, double b, double tolerance = 1E-10)
		{
			return Math.Abs(a - b) < tolerance;
		}
	}
	public static class WardenObjectiveEventCollections
	{
		private static int GetLayerFromBulkhead(Bulkhead bulkhead)
		{
			switch (bulkhead)
			{
			case Bulkhead.Main:
				return 0;
			case Bulkhead.Extreme:
				return 1;
			case Bulkhead.Overload:
				return 2;
			default:
			{
				global::<PrivateImplementationDetails>.ThrowSwitchExpressionException(bulkhead);
				int result = default(int);
				return result;
			}
			}
		}

		public static ICollection<WardenObjectiveEvent> AddLockDoor(this ICollection<WardenObjectiveEvent> events, Bulkhead bulkhead, int zoneIndex, double delay = 0.0, WardenObjectiveEventTrigger trigger = WardenObjectiveEventTrigger.OnStart, string? lockMessage = null)
		{
			events.Add(new WardenObjectiveEvent
			{
				Type = WardenObjectiveEventType.LockSecurityDoor,
				DimensionIndex = 0,
				Layer = GetLayerFromBulkhead(bulkhead),
				LocalIndex = zoneIndex,
				SpecialText = (lockMessage ?? Lore.LockedDoorMessage)
			});
			return events;
		}

		public static ICollection<WardenObjectiveEvent> AddLockExtreme(this ICollection<WardenObjectiveEvent> events, double delay = 0.0, WardenObjectiveEventTrigger trigger = WardenObjectiveEventTrigger.OnStart, string? lockMessage = null)
		{
			return events.AddLockDoor(Bulkhead.Extreme, 0, delay, trigger, lockMessage);
		}

		public static ICollection<WardenObjectiveEvent> AddLockOverload(this ICollection<WardenObjectiveEvent> events, double delay = 0.0, WardenObjectiveEventTrigger trigger = WardenObjectiveEventTrigger.OnStart, string? lockMessage = null)
		{
			return events.AddLockDoor(Bulkhead.Overload, 0, delay, trigger, lockMessage);
		}

		public static ICollection<WardenObjectiveEvent> AddStopLoop(this ICollection<WardenObjectiveEvent> events, int loopId, double delay = 0.0)
		{
			events.Add(new WardenObjectiveEvent
			{
				Type = WardenObjectiveEventType.StopEventLoop,
				Count = loopId,
				Delay = delay
			});
			return events;
		}

		public static ICollection<WardenObjectiveEvent> AddFillFog(this ICollection<WardenObjectiveEvent> events, double delay = 5.0, double duration = 20.0, string? message = ":://CRITICAL FAILURE - VENTILATION SYSTEMS OFFLINE")
		{
			return events.AddSetFog(Fog.FullFog, delay, duration, message);
		}

		public static ICollection<WardenObjectiveEvent> AddSetFog(this ICollection<WardenObjectiveEvent> events, Fog fogSettings, double delay = 5.0, double duration = 20.0, string? message = ":://CRITICAL FAILURE - VENTILATION SYSTEMS OFFLINE")
		{
			events.Add(new WardenObjectiveEvent
			{
				Type = WardenObjectiveEventType.SetFogSettings,
				Trigger = WardenObjectiveEventTrigger.OnStart,
				FogSetting = fogSettings.PersistentId,
				FogTransitionDuration = duration,
				Delay = delay + 0.7
			});
			if (message == null)
			{
				return events;
			}
			events.Add(new WardenObjectiveEvent
			{
				Type = WardenObjectiveEventType.PlaySound,
				Trigger = WardenObjectiveEventTrigger.OnStart,
				SoundId = Sound.KdsDeepVentilationProcedure,
				Delay = delay
			});
			events.Add(new WardenObjectiveEvent
			{
				Type = WardenObjectiveEventType.None,
				Trigger = WardenObjectiveEventTrigger.OnStart,
				Delay = delay + 4.0,
				WardenIntel = message
			});
			return events;
		}

		public static ICollection<WardenObjectiveEvent> AddAllLightsOff(this ICollection<WardenObjectiveEvent> events, double delay = 0.0, WardenObjectiveEventTrigger trigger = WardenObjectiveEventTrigger.OnStart)
		{
			events.Add(new WardenObjectiveEvent
			{
				Type = WardenObjectiveEventType.AllLightsOff,
				Trigger = trigger,
				Delay = delay
			});
			return events;
		}

		public static ICollection<WardenObjectiveEvent> AddToggleSecuritySensors(this ICollection<WardenObjectiveEvent> events, bool enabled, int sensorIndex, double delay = 0.0)
		{
			events.Add(new WardenObjectiveEvent
			{
				Type = WardenObjectiveEventType.ToggleSecuritySensor,
				Enabled = enabled,
				Count = sensorIndex,
				Delay = delay
			});
			return events;
		}

		public static ICollection<WardenObjectiveEvent> AddAdjustTimer(this ICollection<WardenObjectiveEvent> events, double duration, double delay = 0.0)
		{
			events.Add(new WardenObjectiveEvent
			{
				Type = WardenObjectiveEventType.AdjustAwoTimer,
				Duration = duration,
				Delay = delay
			});
			return events;
		}
	}
	public static class ZoneNodeCollections
	{
		public static ICollection<(ZoneNode, Zone?)> WithZones(this ICollection<ZoneNode> nodes, LayoutPlanner planner)
		{
			LayoutPlanner planner2 = planner;
			return nodes.Select((ZoneNode node) => (node, planner2.GetZone(node))).ToList();
		}
	}
}
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<Dimension> Dimensions { get; private set; } = new BlocksBin<Dimension>();


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


		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<ExpeditionBalance> ExpeditionBalances { get; private set; } = new BlocksBin<ExpeditionBalance>();


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


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


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


		public static LazyBlocksBin<LightSettings> LightSettings { get; private set; } = new LazyBlocksBin<LightSettings>();


		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 LazyBlocksBin<WaveSettings> WaveSettings { get; private set; } = new LazyBlocksBin<WaveSettings>();


		public static void Setup()
		{
			AutogenRundown.DataBlocks.Light.LightSettings.Setup();
			AutogenRundown.DataBlocks.Light.LightSettings.SaveStatic();
			Text.Setup();
			Text.SaveStatic();
			Enemy_New.Setup();
			EnemyGroup.Setup();
			EnemyPopulation.Setup();
			WavePopulation.Setup();
			AutogenRundown.DataBlocks.Alarms.WaveSettings.Setup();
			BigPickupDistribution.SaveStatic();
			ChainedPuzzle.SaveStatic();
			ConsumableDistribution.SaveStatic();
			Dimension.SaveStatic();
			EnemyGroup.SaveStatic();
			EnemyPopulation.SaveStatic();
			ExpeditionBalance.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");
			Dimensions.Save("Dimension");
			Enemy.Save("Enemy");
			EnemyGroups.Save("EnemyGroup");
			EnemyPopulations.Save("EnemyPopulation");
			ExpeditionBalances.Save("ExpeditionBalance");
			Fogs.Save("FogSettings");
			GameSetups.Save("GameSetup");
			LevelLayouts.Save("LevelLayout");
			LightSettings.Save("LightSettings");
			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 bool Contains(T? block)
		{
			return Blocks.Contains(block);
		}

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

		public T? GetBlock(Predicate<T> predicate)
		{
			return Blocks.Find(predicate);
		}

		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 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; } = 1.0;


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


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


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


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

		public static readonly Color MenuVisuals_MonthlyE = new Color
		{
			Alpha = 1.0,
			Red = 0.1509804,
			Green = 0.4190196,
			Blue = 0.858823538
		};

		public static readonly Color MenuVisuals_DailyE = new Color
		{
			Alpha = 1.0,
			Red = 0.8509804,
			Green = 0.4190196,
			Blue = 0.158823538
		};

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

		public static readonly Color InfectiousFog_R8D1 = new Color
		{
			Red = 0.356862754,
			Green = 1.0,
			Blue = 0.545098066,
			Alpha = 0.03137255
		};

		[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
				{
					Weight = 8.0,
					Item = Item.LockMelter
				},
				new ItemSpawn
				{
					Weight = 1.0,
					Item = Item.CfoamGrenade
				},
				new ItemSpawn
				{
					Weight = 1.0,
					Item = Item.ExplosiveTripmine
				},
				new ItemSpawn
				{
					Weight = 1.0,
					Item = Item.LongRangeFlashlight
				}
			})
		};

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

		public static ConsumableDistribution Alarms_FogRepellers = new ConsumableDistribution
		{
			SpawnsPerZone = 12u,
			SpawnData = Collections.Flatten<ItemSpawn>(ItemSpawn.GlowSticks(), new List<ItemSpawn>
			{
				new ItemSpawn
				{
					Weight = 8.0,
					Item = Item.FogRepeller
				}
			})
		};

		public static ConsumableDistribution Reactor_FogRepellers = new ConsumableDistribution
		{
			SpawnsPerZone = 10u,
			SpawnData = Collections.Flatten<ItemSpawn>(ItemSpawn.GlowSticks(2.0), new List<ItemSpawn>
			{
				new ItemSpawn
				{
					Weight = 8.0,
					Item = Item.FogRepeller
				}
			})
		};

		public new static void SaveStatic()
		{
			Bins.ConsumableDistributions.AddBlock(Baseline);
			Bins.ConsumableDistributions.AddBlock(Baseline_FogRepellers);
			Bins.ConsumableDistributions.AddBlock(Alarms_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(/*Could not decode attribute arguments.*/)]
		public string? Comment { 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 record Dimension : DataBlock
	{
		[JsonProperty("DimensionData")]
		public AutogenRundown.DataBlocks.Dimensions.DimensionData Data { get; init; } = new AutogenRundown.DataBlocks.Dimensions.DimensionData();


		public static readonly Dimension None = new Dimension
		{
			PersistentId = 0u,
			Name = "None"
		};

		public static readonly Dimension PouncerArena = new Dimension
		{
			PersistentId = 14u,
			Name = "Dimension_Pouncer_Arena",
			Data = new AutogenRundown.DataBlocks.Dimensions.DimensionData
			{
				LevelLayoutData = 0,
				DimensionGeomorph = "Assets/AssetPrefabs/Complex/Dimensions/PouncerArena/Dimension_Pouncer_Arena_01.prefab",
				VerticalExtentsUp = 50.0,
				VerticalExtentsDown = 10.0,
				DimensionResourceSetID = 47,
				DimensionFogData = 93,
				EnvironmentWetness = 0.199,
				DustColor = new Color
				{
					Alpha = 1.0,
					Red = 0.65,
					Green = 0.6042968,
					Blue = 0.487499952
				},
				DustAlphaBoost = 0.0,
				DustTurbulence = 1.0,
				SoundEventOnWarpTo = 1998147319u,
				DisableVFXEventOnWarp = false,
				UseLocalDimensionSeeds = false,
				ForbidWaveSpawning = true,
				ForbidCarryItemWarps = true,
				LeaveDeployablesOnWarp = true,
				IsStaticDimension = true,
				StaticZoneSeed = 0,
				StaticMarkerSeed = 0,
				StaticLightSeed = 0,
				StaticLightSettings = 20,
				StaticAliasOverride = -1,
				StaticEnemySpawningInZone = new JArray(),
				StaticAllowResourceContainerAllocation = false,
				StaticAllowSmallPickupsAllocation = false,
				StaticForceBigPickupsAllocation = false,
				StaticConsumableDistributionInZone = 0,
				StaticBigPickupDistributionInZone = 0,
				StaticGroundSpawnersInZone = 0,
				StaticHealthMulti = 0.0,
				StaticToolAmmoMulti = 0.0,
				StaticWeaponAmmoMulti = 0.0,
				StaticDisinfectionMulti = 0.0,
				ForbidTerminalsInDimension = true,
				IsOutside = true,
				LightAzimuth = -4.7,
				LightElevation = 81.4,
				LightIntensity = 0.3198,
				AmbientIntensity = 1.106,
				ReflectionsIntensity = 1.547,
				GodrayRange = 7622.0,
				GodrayExponent = 1.227,
				AtmosphereData = 3,
				AtmosphereDensity