using System;
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 System.Text.RegularExpressions;
using AIGraph;
using AutogenRundown.DataBlocks;
using AutogenRundown.DataBlocks.Alarms;
using AutogenRundown.DataBlocks.ComplexResourceSets;
using AutogenRundown.DataBlocks.Custom.AdvancedWardenObjective;
using AutogenRundown.DataBlocks.Custom.AutogenRundown;
using AutogenRundown.DataBlocks.Custom.AutogenRundown.SecurityDoors;
using AutogenRundown.DataBlocks.Custom.AutogenRundown.TerminalPlacements;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization.Abilities;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization.EnemyAbilities;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization.Models;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization.Models.Bones;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization.Models.Glows;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization.Models.Materials;
using AutogenRundown.DataBlocks.Custom.ExtraEnemyCustomization.Projectiles;
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.CentralGeneratorCluster;
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.Managers;
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 GTFO.API;
using GameData;
using HarmonyLib;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using LevelGeneration;
using Localization;
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.CentralGeneratorCluster,
				WardenObjectiveType.HsuActivateSmall,
				WardenObjectiveType.Survival,
				WardenObjectiveType.GatherTerminal,
				WardenObjectiveType.CorruptedTerminalUplink,
				WardenObjectiveType.TimedTerminalSequence
			};
			list.RemoveAll((WardenObjectiveType o) => exclude2.Contains(o));
			if (!Bulkhead.HasFlag(Bulkhead.Main))
			{
				list.Remove(WardenObjectiveType.HsuActivateSmall);
				list.Remove(WardenObjectiveType.ClearPath);
				list.Remove(WardenObjectiveType.Survival);
			}
			if (Bulkhead.HasFlag(Bulkhead.Main))
			{
				list.Remove(WardenObjectiveType.SpecialTerminalCommand);
			}
			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();
		}
	}
	[Obsolete("Use ComplexResourceSet")]
	public class ComplexResource
	{
	}
	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 = 63u;

		private static uint wavePopulationPid = 200u;

		private static uint waveSettingsPid = 1u;

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


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


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


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


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


		public static int SeasonalYear { get; set; } = 1;


		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 int BetweenConstrained(int min, int max, IEnumerable<(int start, int end)> blockedRanges, int freeAfter = 1)
		{
			List<(int start, int end)> list = MergeRanges(from r in blockedRanges
				select (Math.Max(min, Math.Min(r.start, r.end)), Math.Min(max, Math.Max(r.start, r.end))) into r
				where r.start <= r.end
				orderby r.start, r.end
				select r);
			List<(int, int)> list2 = new List<(int, int)>();
			int num = min;
			foreach (var (num2, num3) in list)
			{
				if (num < num2)
				{
					list2.Add((num, num2 - 1));
				}
				num = num3 + 1;
				if (num > max)
				{
					break;
				}
			}
			if (num <= max)
			{
				list2.Add((num, max));
			}
			List<(int, int)> list3 = new List<(int, int)>();
			int num4 = 0;
			foreach (var item2 in list2)
			{
				int item = item2.Item1;
				int num5 = item2.Item2 - freeAfter;
				if (num5 >= item)
				{
					int num6 = num5 - item + 1;
					list3.Add((item, num6));
					num4 += num6;
				}
			}
			if (num4 == 0)
			{
				throw new InvalidOperationException("No valid numbers available with the given constraints and tail requirement.");
			}
			int num7 = Between(0, num4);
			foreach (var (num8, num9) in list3)
			{
				if (num7 < num9)
				{
					return num8 + num7;
				}
				num7 -= num9;
			}
			throw new InvalidOperationException("Selection failed unexpectedly.");
		}

		private static List<(int start, int end)> MergeRanges(IEnumerable<(int start, int end)> ranges)
		{
			List<(int, int)> list = new List<(int, int)>();
			int? num = null;
			int num2 = 0;
			foreach (var (num3, num4) in ranges)
			{
				if (!num.HasValue)
				{
					num = num3;
					num2 = num4;
				}
				else if (num3 <= num2 + 1)
				{
					num2 = Math.Max(num2, num4);
				}
				else
				{
					list.Add((num.Value, num2));
					num = num3;
					num2 = num4;
				}
			}
			if (num.HasValue)
			{
				list.Add((num.Value, num2));
			}
			return list;
		}

		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 void DrawSelectRun_PersistedList(ICollection<(double weight, int count, Action action)> collection)
		{
		}

		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 T DrawSelectFrequency<T>(ICollection<(double, int, T)> collection)
		{
			int num = collection.Sum<(double, int, T)>(((double, int, T) x) => x.Item2);
			double num2 = Random.NextDouble() * (double)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;
				int item = tuple2.Item2;
				T item2 = tuple2.Item3;
				num3 += (double)item;
				if (num2 <= num3)
				{
					collection.Remove(tuple);
					tuple.Item2--;
					if (tuple.Item2 > 0)
					{
						collection.Add(tuple);
					}
					return item2;
				}
			}
			(double, int, T) item3 = collection.Last();
			collection.Remove(item3);
			item3.Item2--;
			if (item3.Item2 > 0)
			{
				collection.Add(item3);
			}
			return item3.Item3;
		}

		public static uint GetPersistentId(PidOffsets offset = PidOffsets.Normal)
		{
			return offset switch
			{
				PidOffsets.None => 0u, 
				PidOffsets.Normal => pid++, 
				PidOffsets.Enemy => enemyPid++, 
				PidOffsets.EnemyGroup => enemyGroupPid++, 
				PidOffsets.WavePopulation => wavePopulationPid++, 
				PidOffsets.WaveSettings => waveSettingsPid++, 
				_ => throw new ArgumentOutOfRangeException("offset", offset, null), 
			};
		}

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

		public static string GetSeason(int month)
		{
			return (new string[4] { "Winter", "Spring", "Summer", "Fall" })[month % 12 / 3];
		}

		public static int GetSeasonYear(DateTime date)
		{
			int month = date.Month;
			if ((uint)(month - 1) <= 1u)
			{
				return date.Year - 1;
			}
			return date.Year;
		}

		public static void SetSeasonSeed(string seed = "")
		{
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			DateTime utcNow = DateTime.UtcNow;
			TimeZoneInfo destinationTimeZone = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
			DateTime dateTime = TimeZoneInfo.ConvertTimeFromUtc(utcNow, destinationTimeZone);
			bool flag = false;
			InputSeasonalSeed = $"{GetSeason(dateTime.Month)}_{GetSeasonYear(dateTime)}".ToUpperInvariant();
			bool flag2 = default(bool);
			if (!string.IsNullOrWhiteSpace(seed))
			{
				if (TryParseSeasonalSeed(seed, out string seasonTitleCase, out int year))
				{
					InputSeasonalSeed = $"{seasonTitleCase.ToUpperInvariant()}_{year}";
					SeasonalSeason = seasonTitleCase;
					SeasonalYear = year;
					flag = true;
				}
				else
				{
					ManualLogSource logger = Plugin.Logger;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(33, 1, ref flag2);
					if (flag2)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unable to parse seasonal seed: \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(seed);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
					}
					logger.LogWarning(val);
				}
			}
			if (!flag)
			{
				SeasonalSeason = GetSeason(dateTime.Month);
				SeasonalYear = GetSeasonYear(dateTime);
			}
			ManualLogSource logger2 = Plugin.Logger;
			BepInExDebugLogInterpolatedStringHandler val2 = new BepInExDebugLogInterpolatedStringHandler(20, 1, ref flag2);
			if (flag2)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Seasonal date seed: ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<DateTime>(dateTime);
			}
			logger2.LogDebug(val2);
			string inputSeasonalSeed = InputSeasonalSeed;
			string text = $"{SeasonalSeason} {SeasonalYear}";
			Seed = inputSeasonalSeed;
			DisplaySeed = "<color=orange>" + text + "</color>";
		}

		private static bool TryParseSeasonalSeed(string seed, out string seasonTitleCase, out int year)
		{
			seasonTitleCase = "";
			year = 0;
			if (string.IsNullOrWhiteSpace(seed))
			{
				return false;
			}
			string[] array = seed.Trim().Replace('-', ' ').Replace('_', ' ')
				.ToUpperInvariant()
				.Split(' ', StringSplitOptions.RemoveEmptyEntries);
			if (array.Length != 2)
			{
				return false;
			}
			string text = null;
			string text2 = null;
			if (IsSeasonToken(array[0]))
			{
				text = array[0];
				text2 = array[1];
			}
			else
			{
				if (!IsSeasonToken(array[1]))
				{
					return false;
				}
				text = array[1];
				text2 = array[0];
			}
			if (!int.TryParse(text2, out year) || year < 1 || year > 9999)
			{
				return false;
			}
			seasonTitleCase = text switch
			{
				"WINTER" => "Winter", 
				"SPRING" => "Spring", 
				"SUMMER" => "Summer", 
				"AUTUMN" => "Fall", 
				"FALL" => "Fall", 
				_ => "", 
			};
			return seasonTitleCase != "";
		}

		private static bool IsSeasonToken(string token)
		{
			switch (token)
			{
			default:
				return token == "AUTUMN";
			case "WINTER":
			case "SPRING":
			case "SUMMER":
			case "FALL":
				return true;
			}
		}

		public static void SetMonthSeed(string seed = "")
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			DateTime utcNow = DateTime.UtcNow;
			TimeZoneInfo destinationTimeZone = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
			DateTime result = TimeZoneInfo.ConvertTimeFromUtc(utcNow, destinationTimeZone);
			InputMonthlySeed = $"{result:yyyy_MM}";
			bool flag = default(bool);
			if (!string.IsNullOrWhiteSpace(seed))
			{
				if (DateTime.TryParseExact(seed.Trim(), "yyyy_MM", CultureInfo.InvariantCulture, DateTimeStyles.None, out result))
				{
					InputMonthlySeed = seed.Trim();
				}
				else
				{
					ManualLogSource logger = Plugin.Logger;
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(32, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unable to parse monthly seed: \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(seed);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
					}
					logger.LogWarning(val);
				}
			}
			ManualLogSource logger2 = Plugin.Logger;
			BepInExDebugLogInterpolatedStringHandler val2 = new BepInExDebugLogInterpolatedStringHandler(19, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Monthly date seed: ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<DateTime>(result);
			}
			logger2.LogDebug(val2);
			string seed2 = $"{result:yyyy_MM}";
			string text = $"{result:MMMM}";
			Seed = seed2;
			DisplaySeed = "<color=orange>" + text + "</color>";
			MonthNumber = result.Month;
		}

		public static void SetWeeklySeed(string seed = "")
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected O, but got Unknown
			DateTime utcNow = DateTime.UtcNow;
			TimeZoneInfo destinationTimeZone = TimeZoneInfo.FindSystemTimeZoneById("Pacific Standard Time");
			DateTime result = TimeZoneInfo.ConvertTimeFromUtc(utcNow, destinationTimeZone);
			InputWeeklySeed = $"{result:yyyy_MM_dd}";
			if (!string.IsNullOrWhiteSpace(seed))
			{
				if (DateTime.TryParseExact(seed.Trim(), "yyyy_MM_dd", CultureInfo.InvariantCulture, DateTimeStyles.None, out result))
				{
					InputWeeklySeed = seed.Trim();
				}
				else
				{
					ManualLogSource logger = Plugin.Logger;
					bool flag = default(bool);
					BepInExWarningLogInterpolatedStringHandler val = new BepInExWarningLogInterpolatedStringHandler(31, 1, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Unable to parse weekly seed: \"");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(seed);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\"");
					}
					logger.LogWarning(val);
				}
			}
			int weekOfYear = CultureInfo.InvariantCulture.Calendar.GetWeekOfYear(result, CalendarWeekRule.FirstFullWeek, DayOfWeek.Tuesday);
			string seed2 = $"{result:yyyy}_W{weekOfYear}";
			string text = $"Week {weekOfYear}";
			Seed = seed2;
			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>";
				InputDailySeed = seed.Trim();
			}
			else
			{
				GenerateTimeSeed();
				InputDailySeed = Seed;
			}
		}

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

		public 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();
			ArsenalityRebalance.Configure();
			VanillaReloaded.Configure();
		}
	}
	[BepInPlugin("000-the_tavern-AutogenRundown", "AutogenRundown", "0.75.2")]
	[BepInProcess("GTFO.exe")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BasePlugin
	{
		public const string Version = "0.75.2";

		public const string Name = "the_tavern-AutogenRundown";

		public static string GameRevision => CellBuildData.GetRevision().ToString();

		public static string GameDataPath => Path.Combine(Paths.BepInExRootPath, "GameData", GameRevision);

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


		public static bool Config_UsePlayerColoredGlowsticks { get; set; }

		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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Expected O, but got Unknown
			//IL_006a: Expected O, but got Unknown
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Expected O, but got Unknown
			//IL_009a: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Expected O, but got Unknown
			//IL_00ca: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_00f6: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected O, but got Unknown
			//IL_0121: Expected O, but got Unknown
			//IL_01ec: 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.Seeds", "DailySeed"), "", new ConfigDescription("Specify a seed for the Daily Rundown generation. Any string can be used here, this defaults to today's date. E.g. 2025_08_15 for August 15th 2025.", (AcceptableValueBase)null, Array.Empty<object>()));
			ConfigEntry<string> val2 = ((BasePlugin)this).Config.Bind<string>(new ConfigDefinition("AutogenRundown.Seeds", "WeeklySeed"), "", new ConfigDescription("Specify a seed for the Weekly Rundown.\nExpected format is \"YYYY_MM_DD\" where YYYY is the year, MM is the month, and DD is the day.\ne.g 2025_08_03 for August 3rd 2025.\nWeek number is automatically calculated from the date.", (AcceptableValueBase)null, Array.Empty<object>()));
			ConfigEntry<string> val3 = ((BasePlugin)this).Config.Bind<string>(new ConfigDefinition("AutogenRundown.Seeds", "MonthlySeed"), "", new ConfigDescription("Specify a seed for the Monthly Rundown.\nExpected format is \"YYYY_MM\" where YYYY is the year (e.g 2025) and MM is the month (e.g 03 for March)", (AcceptableValueBase)null, Array.Empty<object>()));
			ConfigEntry<string> val4 = ((BasePlugin)this).Config.Bind<string>(new ConfigDefinition("AutogenRundown.Seeds", "SeasonalSeed"), "", new ConfigDescription("Specify a seed for the Seasonal Rundown.\nExpected format is \"SEASON_YYYY\" where YYYY is the year (e.g 2025) and SEASONis one of the four seasons (Winter, Spring, Summer, Fall).e.g SPRING_2025", (AcceptableValueBase)null, Array.Empty<object>()));
			ConfigEntry<bool> obj = ((BasePlugin)this).Config.Bind<bool>(new ConfigDefinition("AutogenRundown", "RegenerateOnStartup"), true, new ConfigDescription("Should datablocks be regenerated on game startup. Applies to all rundowns.", (AcceptableValueBase)null, Array.Empty<object>()));
			Config_UsePlayerColoredGlowsticks = ((BasePlugin)this).Config.Bind<bool>(new ConfigDefinition("AutogenRundown", "UsePlayerColorGlowsticks"), false, new ConfigDescription("Use per player color glow sticks. Client side only.", (AcceptableValueBase)null, Array.Empty<object>())).Value;
			if (val.Value == "Todays date, YYYY_MM_DD")
			{
				val.Value = "";
			}
			if (val2.Value == "Todays date, YYYY_MM_DD")
			{
				val2.Value = "";
			}
			if (val3.Value == "Todays month, YYYY_MM")
			{
				val3.Value = "";
			}
			((BasePlugin)this).Config.Save();
			if (obj.Value)
			{
				Peers.Init();
				RundownFactory.Build(val.Value, val2.Value, val3.Value, val4.Value);
			}
			PlayFabManager.OnTitleDataUpdated += Action.op_Implicit((Action)RundownNames.OnTitleDataUpdated);
			Patch_LG_ComputerTerminal_Setup.Setup();
			Patch_LG_SecurityDoor.Setup();
			GameDataAPI.OnGameDataInitialized += Patch_CentralGeneratorCluster.Setup;
			new Harmony("the_tavern-AutogenRundown").PatchAll();
		}
	}
	public enum PluginRundown
	{
		None,
		Daily,
		Weekly,
		Monthly,
		Seasonal
	}
	public record Prefab
	{
		[JsonProperty("Prefab")]
		public string Asset { get; set; } = "";


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


		public int Shard { get; set; } = 1;

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

		private static void CleanFolders()
		{
			string path = Path.Combine(Plugin.GameDataPath, "Custom", "AutogenRundown");
			if (Directory.Exists(path))
			{
				Directory.Delete(path, recursive: true);
			}
		}

		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 BuildSeasonalRundown(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("FALL_2025", new List<List<int>>
			{
				new List<int> { 1, 1, 1, 1, 1 },
				new List<int> { 1, 1, 1, 1, 1, 3 },
				new List<int> { 2, 1, 2, 1, 1, 1 },
				new List<int> { 1, 1, 1, 1, 2, 2 },
				new List<int> { 1, 1, 2, 1 }
			});
			dictionary.TryGetValue(Generator.Seed, out var value);
			if (value == null)
			{
				value = new List<List<int>>
				{
					new List<int> { 1, 1, 1, 1, 1 },
					new List<int> { 1, 1, 1, 1, 1, 1 },
					new List<int> { 1, 1, 1, 1, 1, 1 },
					new List<int> { 1, 1, 1, 1, 1, 1 },
					new List<int> { 1, 1, 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),
				(1.0, 1, WardenObjectiveType.SpecialTerminalCommand),
				(1.0, 2, WardenObjectiveType.RetrieveBigItems),
				(1.0, 2, WardenObjectiveType.PowerCellDistribution),
				(1.0, 3, WardenObjectiveType.TerminalUplink),
				(1.0, 3, WardenObjectiveType.CentralGeneratorCluster),
				(1.0, 3, WardenObjectiveType.HsuActivateSmall),
				(1.0, 3, WardenObjectiveType.Survival),
				(1.0, 2, WardenObjectiveType.GatherTerminal),
				(1.0, 2, WardenObjectiveType.CorruptedTerminalUplink),
				(1.0, 2, WardenObjectiveType.TimedTerminalSequence)
			};
			List<(double, int, Complex)> collection3 = new List<(double, int, Complex)>
			{
				(1.0, 14, Complex.Mining),
				(1.0, 14, Complex.Tech),
				(1.0, 12, Complex.Service)
			};
			List<(double, Bulkhead)> bulkheadChanceTable = new List<(double, Bulkhead)>
			{
				(0.2, Bulkhead.Main),
				(0.3, Bulkhead.Main | Bulkhead.Extreme),
				(0.25, Bulkhead.Main | Bulkhead.Overload),
				(0.25, Bulkhead.PrisonerEfficiency)
			};
			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,
					BulkheadChanceTable = bulkheadChanceTable
				});
				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,
					BulkheadChanceTable = bulkheadChanceTable
				});
				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,
					BulkheadChanceTable = bulkheadChanceTable
				});
				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,
					BulkheadChanceTable = bulkheadChanceTable
				});
				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,
					BulkheadChanceTable = bulkheadChanceTable
				});
				rundown.AddLevel(level5);
			}
			rundown.UseTierUnlockRequirements = true;
			rundown.ReqToReachTierB.MainSectors = Math.Max(1, rundown.TierA.Count - 3);
			rundown.ReqToReachTierC.MainSectors = Math.Max(0, rundown.ReqToReachTierB.MainSectors + rundown.TierB.Count - 3);
			rundown.ReqToReachTierD.MainSectors = Math.Max(0, rundown.ReqToReachTierC.MainSectors + rundown.TierC.Count - 3);
			rundown.ReqToReachTierE.MainSectors = Math.Max(0, rundown.ReqToReachTierD.MainSectors + rundown.TierD.Count - 3);
			rundown.VisualsETier = Color.MenuVisuals_SeasonalE;
			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_08", new List<List<int>>
			{
				new List<int> { 2, 1 },
				new List<int> { 1, 1 },
				new List<int> { 1, 1, 1, 1 },
				new List<int> { 1, 1, 1, 1 },
				new List<int> { 1, 2, 1 }
			});
			dictionary.Add("2025_09", new List<List<int>>
			{
				new List<int> { 1, 1, 2 },
				new List<int> { 1, 1 },
				new List<int> { 2, 1, 1, 2 },
				new List<int> { 1, 1, 1, 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),
				(1.0, 1, WardenObjectiveType.SpecialTerminalCommand),
				(1.0, 2, WardenObjectiveType.RetrieveBigItems),
				(1.0, 2, WardenObjectiveType.PowerCellDistribution),
				(1.0, 3, WardenObjectiveType.TerminalUplink),
				(1.0, 3, WardenObjectiveType.CentralGeneratorCluster),
				(1.0, 3, WardenObjectiveType.HsuActivateSmall),
				(1.0, 3, WardenObjectiveType.Survival),
				(1.0, 2, WardenObjectiveType.GatherTerminal),
				(1.0, 2, WardenObjectiveType.CorruptedTerminalUplink),
				(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, string weeklySeed, string monthlySeed, string seasonalSeed)
		{
			CleanFolders();
			Bins.Setup();
			LayoutDefinitions.Setup();
			GameSetup gameSetup = new GameSetup
			{
				PersistentId = 1u,
				Name = "Default"
			};
			Generator.SetSeasonSeed(seasonalSeed);
			Generator.Reload();
			string text = Generator.Pick(Words.Adjectives) + " " + Generator.Pick(Words.NounsRundown);
			Rundown block = BuildSeasonalRundown(new Rundown
			{
				PersistentId = Rundown.R_Seasonal,
				Title = $"{Generator.SeasonalSeason.ToUpper()} '{Generator.SeasonalYear % 100}",
				StoryTitle = "SEASON " + Generator.DisplaySeed + "\r\nTITLE: " + text.ToUpper()
			});
			Bins.Rundowns.AddBlock(block);
			Generator.SetMonthSeed(monthlySeed);
			Generator.Reload();
			string text2 = Words.RundownNameMonthly();
			Rundown block2 = BuildMonthlyRundown(new Rundown
			{
				PersistentId = Rundown.R_Monthly,
				Title = (text2.ToUpper() ?? ""),
				StoryTitle = "MONTHLY " + Generator.DisplaySeed + "\r\nTITLE: " + text2.ToUpper()
			});
			Bins.Rundowns.AddBlock(block2);
			Generator.SetWeeklySeed(weeklySeed);
			Generator.Reload();
			string text3 = Generator.Pick(Words.Adjectives) + " " + Generator.Pick(Words.NounsRundown);
			bool withUnlocks = false;
			Rundown rundown = BuildRundown(new Rundown
			{
				PersistentId = Rundown.R_Weekly,
				Title = (text3.ToUpper() ?? ""),
				StoryTitle = "WEEKLY " + Generator.DisplaySeed + "\r\nTITLE: " + text3.ToUpper()
			}, withFixed: false, withUnlocks);
			rundown.VisualsETier = Color.MenuVisuals_WeeklyE;
			Bins.Rundowns.AddBlock(rundown);
			Generator.ReadOrSetSeed(dailySeed);
			Generator.Reload();
			string text4 = Generator.Pick(Words.Adjectives) + " " + Generator.Pick(Words.NounsRundown);
			Rundown rundown2 = BuildRundown(new Rundown
			{
				PersistentId = Rundown.R_Daily,
				Title = (text4.ToUpper() ?? ""),
				StoryTitle = "DAILY " + Generator.DisplaySeed + "\r\nTITLE: " + text4.ToUpper(),
				TierA_Count = 1,
				TierD_Count = 3,
				TierE_Count = 1
			}, withFixed: true, withUnlocks: false);
			rundown2.VisualsETier = Color.MenuVisuals_DailyE;
			Bins.Rundowns.AddBlock(rundown2);
			gameSetup.RundownIdsToLoad = new List<uint>
			{
				Rundown.R_Daily,
				Rundown.R_Monthly,
				Rundown.R_Weekly,
				Rundown.R_Daily,
				Rundown.R_Daily,
				Rundown.R_Daily,
				Rundown.R_Daily,
				Rundown.R_Seasonal
			};
			Bins.GameSetups.AddBlock(gameSetup);
			Peers.Configure();
			Bins.Save();
			EnemyCustomization.Ability.Save();
			EnemyCustomization.EnemyAbility.Save();
			EnemyCustomization.Model.Save();
			EnemyCustomization.Projectile.Save();
			GlobalConfig.Save();
		}
	}
}
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 class Arsenality : SupportedMod
	{
		public static string MOD_NAME = "W33B-Arsenality";

		public Arsenality()
		{
			ModName = "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 ArsenalityRebalance : SupportedMod
	{
		public ArsenalityRebalance()
		{
			ModName = "leezurli-ArsenalityRebalance";
		}

		public static void Configure()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			ArsenalityRebalance arsenalityRebalance = new ArsenalityRebalance();
			if (!Peers.HasMod(arsenalityRebalance.ModName))
			{
				return;
			}
			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>(arsenalityRebalance.ModName);
			}
			logger.LogInfo(val);
			arsenalityRebalance.CopyGameDataJson();
			string text = Path.Combine(arsenalityRebalance.PluginFolder, "GearPartTransform.json");
			string text2 = Path.Combine(arsenalityRebalance.GameDataFolder, "Custom", "mccad00", "GearPartTransform.json");
			if (File.Exists(text))
			{
				Directory.CreateDirectory(Path.GetDirectoryName(text2));
				File.Copy(text, text2, overwrite: true);
				ManualLogSource logger2 = Plugin.Logger;
				BepInExDebugLogInterpolatedStringHandler val2 = new BepInExDebugLogInterpolatedStringHandler(34, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(arsenalityRebalance.ModName);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(": Copied -> GearPartTransform.json");
				}
				logger2.LogDebug(val2);
			}
		}
	}
	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 SupportedMod
	{
		protected string ModName = "";

		protected string PluginFolder => Path.Combine(Paths.BepInExRootPath, "plugins", ModName);

		protected string GameDataFolder => Path.Combine(Paths.BepInExRootPath, "GameData", $"{CellBuildData.GetRevision()}");

		protected void CopyGameDataJson()
		{
			Directory.GetFiles(Path.Combine(Paths.BepInExRootPath, "plugins", ModName), "GameData_*DataBlock_bin.json", SearchOption.AllDirectories).ToList().ForEach(delegate(string path)
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002a: Expected O, but got Unknown
				string fileName = Path.GetFileName(path);
				File.Copy(path, Path.Combine(GameDataFolder, fileName), overwrite: true);
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(22, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ModName);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": Copied datablock -> ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(fileName);
				}
				logger.LogDebug(val);
			});
		}

		protected void CopyCustomMccad00()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			string text = Path.Combine("Custom", "mccad00", "GearPartTransform.json");
			string text2 = Path.Combine(PluginFolder, text);
			string text3 = Path.Combine(GameDataFolder, text);
			if (File.Exists(text2))
			{
				Directory.CreateDirectory(Path.GetDirectoryName(text3));
				File.Copy(text2, text3, overwrite: true);
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(12, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ModName);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": Copied -> ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
				}
				logger.LogDebug(val);
			}
		}

		protected void CopyGearPartTransform()
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Expected O, but got Unknown
			string text = "GearPartTransform.json";
			string text2 = Path.Combine(PluginFolder, "GearPartTransform.json");
			string destFileName = Path.Combine(GameDataFolder, "GearPartTransform.json");
			if (File.Exists(text2))
			{
				File.Copy(text2, destFileName, overwrite: true);
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(12, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ModName);
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(": Copied -> ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(text);
				}
				logger.LogDebug(val);
			}
		}
	}
	public class VanillaReloaded : SupportedMod
	{
		public VanillaReloaded()
		{
			ModName = "tru0067-VanillaReloaded";
		}

		public static void Configure()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Expected O, but got Unknown
			VanillaReloaded vanillaReloaded = new VanillaReloaded();
			if (!Peers.HasMod(vanillaReloaded.ModName))
			{
				return;
			}
			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>(vanillaReloaded.ModName);
			}
			logger.LogInfo(val);
			vanillaReloaded.CopyGameDataJson();
			string text = Path.Combine("Custom", "ExtraWeaponCustomization", "VanillaReloaded-ExtraWeaponCustomization.json");
			string text2 = Path.Combine(vanillaReloaded.PluginFolder, text);
			string text3 = Path.Combine(vanillaReloaded.GameDataFolder, text);
			if (File.Exists(text2))
			{
				Directory.CreateDirectory(Path.GetDirectoryName(text3));
				File.Copy(text2, text3, overwrite: true);
				ManualLogSource logger2 = Plugin.Logger;
				BepInExDebugLogInterpolatedStringHandler val2 = new BepInExDebugLogInterpolatedStringHandler(12, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(vanillaReloaded.ModName);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(": Copied -> ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(text);
				}
				logger2.LogDebug(val2);
			}
		}
	}
	public class VersionNumber
	{
		public int Major { get; set; }

		public int Minor { get; set; }

		public int Patch { get; set; }
	}
}
namespace AutogenRundown.Patches
{
	[HarmonyPatch]
	internal static class Artifacts
	{
		[HarmonyPatch(typeof(DropServerGameSession), "ConsumeBoosters")]
		[HarmonyPrefix]
		internal static bool Pre_DropServerGameSession_ConsumeBoosters()
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			ManualLogSource logger = Plugin.Logger;
			bool flag = default(bool);
			BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(28, 0, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Skipping booster consumption");
			}
			logger.LogInfo(val);
			return false;
		}
	}
	[HarmonyPatch]
	public class Glowsticks
	{
		private const float MaxIntensity = 0.2f;

		private const double FadeInDuration = 6.0;

		private const double FadeOutDuration = 12.0;

		private const double Duration = 75.0;

		[HarmonyPatch(typeof(GlowstickInstance), "Update")]
		[HarmonyPrefix]
		internal static void Pre_GlowstickInstance_Update(GlowstickInstance __instance)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Invalid comparison between Unknown and I4
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			__instance.s_lightLifeTime = 75f;
			if ((int)__instance.m_state == 1 && Numeric.ApproxEqual(__instance.m_progression, 0.0))
			{
				__instance.m_progressionSpeed = 1f / 6f;
			}
			if ((int)__instance.m_state == 3 && Numeric.ApproxEqual(__instance.m_progression, 1.0))
			{
				__instance.m_progressionSpeed = 1f / 12f;
			}
		}

		[HarmonyPatch(typeof(GlowstickInstance), "Update")]
		[HarmonyPostfix]
		internal static void Post_GlowstickInstance_Update(GlowstickInstance __instance)
		{
			//IL_0019: 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_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected I4, but got Unknown
			if (Plugin.Config_UsePlayerColoredGlowsticks)
			{
				((LightBase)__instance.m_light).Color = ((Item)__instance).Owner.Owner.PlayerColor;
				eFadeState state = __instance.m_state;
				switch ((int)state)
				{
				case 0:
					((LightBase)__instance.m_light).Intensity = 0f;
					break;
				case 2:
					((LightBase)__instance.m_light).Intensity = 0.2f;
					break;
				case 1:
				case 3:
					((LightBase)__instance.m_light).Intensity = __instance.m_progression * 0.2f;
					break;
				}
			}
		}
	}
	[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;
		}
	}
	[HarmonyPatch]
	public class Patch_CentralGeneratorCluster
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(LG_DistributionJobUtils), "GetRandomNodeFromZoneForFunction")]
		public static bool FixGeneratorClusterSpawn(LG_Zone zone, ExpeditionFunction func, float randomValue, ref AIG_CourseNode __result)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Invalid comparison between Unknown and I4
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			if ((int)func != 19)
			{
				return true;
			}
			List<LG_Area> areas = zone.m_areas;
			List<LG_Area> list = new List<LG_Area>();
			Enumerator<LG_Area> enumerator = areas.GetEnumerator();
			while (enumerator.MoveNext())
			{
				LG_Area current = enumerator.Current;
				if (current.GetMarkerSpawnerCount((ExpeditionFunction)19) > 0)
				{
					list.Add(current);
				}
			}
			if (list.Count == 0)
			{
				return true;
			}
			int index = Mathf.Clamp((int)(randomValue * (float)list.Count), 0, list.Count - 1);
			LG_Area val = list[index];
			ManualLogSource logger = Plugin.Logger;
			bool flag = default(bool);
			BepInExDebugLogInterpolatedStringHandler val2 = new BepInExDebugLogInterpolatedStringHandler(37, 1, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("Selected area for generator cluster: ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(val.m_navInfo.m_suffix);
			}
			logger.LogDebug(val2);
			__result = val.m_courseNode;
			return false;
		}

		public static void Setup()
		{
			//IL_004d: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Expected O, but got Unknown
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			ServiceMarkerDataBlock block = GameDataBlockBase<ServiceMarkerDataBlock>.GetBlock(11u);
			bool flag = false;
			Enumerator<MarkerComposition> enumerator = block.CommonData.Compositions.GetEnumerator();
			while (enumerator.MoveNext())
			{
				if (enumerator.Current.prefab == "Assets/GameObject/Floodways_open_1400x1000x1000_V09.prefab")
				{
					flag = true;
				}
			}
			if (!flag)
			{
				block.CommonData.Compositions.Add(new MarkerComposition
				{
					weight = 0f,
					preppedInstance = null,
					prefab = "Assets/GameObject/Floodways_open_1400x1000x1000_V09.prefab",
					function = (ExpeditionFunction)19,
					Shard = (AssetBundleShard)4
				});
				ManualLogSource logger = Plugin.Logger;
				bool flag2 = default(bool);
				BepInExDebugLogInterpolatedStringHandler val = new BepInExDebugLogInterpolatedStringHandler(71, 0, ref flag2);
				if (flag2)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Patched ServiceMarkerDataBlock for Generator Cluster in Complex=Service");
				}
				logger.LogDebug(val);
			}
		}
	}
	[HarmonyPatch]
	public class Patch_CM_RundownSelection
	{
		private static readonly Color Disabled = new Color
		{
			r = 0.04f,
			g = 0.04f,
			b = 0.04f,
			a = 0.0314f
		};

		private static readonly Color Enabled = new Color
		{
			r = 0.4f,
			g = 0.4f,
			b = 0.4f,
			a = 0.3137f
		};

		public static Random randomDaily { get; private set; } = new Random(Generator.GetHashCode("Daily_0"));


		public static Random randomWeekly { get; private set; } = new Random(Generator.GetHashCode("Weekly_0"));


		public static Random randomMonthly { get; private set; } = new Random(Generator.GetHashCode("Monthly_0"));


		public static Random randomSeasonal { get; private set; } = new Random(Generator.GetHashCode("Seasonal_0"));


		[HarmonyPostfix]
		[HarmonyPatch(typeof(CM_RundownSelection), "Setup")]
		public static void SetupPostfix(ref CM_RundownSelection __instance)
		{
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_020b: Unknown result type (might be due to invalid IL or missing references)
			string text = ((TMP_Text)__instance.m_rundownText).text;
			if ((!RundownSelection.R1.Enabled && text == "R1") || (!RundownSelection.R2.Enabled && text == "R2") || (!RundownSelection.R3.Enabled && text == "R3") || (!RundownSelection.R4.Enabled && text == "R4") || (!RundownSelection.R5.Enabled && text == "R5") || (!RundownSelection.R6.Enabled && text == "R6") || (!RundownSelection.R7.Enabled && text == "R7") || (!RundownSelection.R8.Enabled && text == "R8"))
			{
				((TMP_Text)__instance.m_rundownText).text = "";
				((CM_Item)__instance).SetButtonEnabled(false);
			}
			if (RundownSelection.R1.Enabled && text == "R1")
			{
				Transform transform = ((Component)__instance).transform;
				transform.localPosition += new Vector3
				{
					x = -10f,
					y = 10f,
					z = 0f
				};
			}
			if (RundownSelection.R2.Enabled && text == "R2")
			{
				Transform transform2 = __instance.m_rundownText.transform;
				transform2.localPosition += new Vector3
				{
					x = 0f,
					y = -10f,
					z = 0f
				};
			}
			if (RundownSelection.R8.Enabled && text == "R8")
			{
				Transform transform3 = __instance.m_rundownText.transform;
				transform3.localPosition += new Vector3
				{
					x = -10f,
					y = -60f,
					z = 0f
				};
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(GUIX_Layer), "SetColor")]
		public static bool GUIX_Layer_SetColor_Prefix(GUIX_Layer __instance, ref Color color)
		{
			//IL_001f: 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_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			if (!RundownSelection.R1.Enabled && LayerHasParent(__instance, RundownSelection.R1.UnityName))
			{
				color = Disabled;
			}
			if (!RundownSelection.R2.Enabled && LayerHasParent(__instance, RundownSelection.R2.UnityName))
			{
				color = Disabled;
			}
			if (!RundownSelection.R3.Enabled && LayerHasParent(__instance, RundownSelection.R3.UnityName))
			{
				color = Disabled;
			}
			if (!RundownSelection.R4.Enabled && LayerHasParent(__instance, RundownSelection.R4.UnityName))
			{
				color = Disabled;
			}
			if (!RundownSelection.R5.Enabled && LayerHasParent(__instance, RundownSelection.R5.UnityName))
			{
				color = Disabled;
			}
			if (!RundownSelection.R6.Enabled && LayerHasParent(__instance, RundownSelection.R6.UnityName))
			{
				color = Disabled;
			}
			if (!RundownSelection.R7.Enabled && LayerHasParent(__instance, RundownSelection.R7.UnityName))
			{
				color = Disabled;
			}
			if (!RundownSelection.R8.Enabled && LayerHasParent(__instance, RundownSelection.R8.UnityName))
			{
				color = Disabled;
			}
			return true;
		}

		private static void SetRadarColor(GUIX_Layer layer, Color color)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				List<Transform> val = CustomExtensions.FindChildrenRecursive(((Component)layer).transform, "radar", false);
				if (val.Count < 1)
				{
					return;
				}
				for (int i = 0; i < val.Count - 1; i++)
				{
					GUIX_ElementSprite component = ((Component)val[i]).GetComponent<GUIX_ElementSprite>();
					if ((Object)(object)component != (Object)null)
					{
						component.spriteRenderer.color = color;
					}
				}
			}
			catch (NullReferenceException)
			{
			}
		}

		private static void SetLineSubsetColor(GUIX_Layer layer, int count, Color color, Random rng)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			List<Transform> val = CustomExtensions.FindChildrenRecursive(((Component)layer).transform, "Line", false);
			if (val == null)
			{
				return;
			}
			int num = 300;
			List<Transform> range = val.GetRange(num, val.Count - num);
			for (int num2 = Math.Min(count, range.Count); num2 > 0; num2--)
			{
				int num3 = rng.Next(0, range.Count);
				try
				{
					GUIX_ElementSprite component = ((Component)range[num3]).GetComponent<GUIX_ElementSprite>();
					if ((Object)(object)component != (Object)null)
					{
						component.spriteRenderer.color = color;
					}
				}
				catch (NullReferenceException)
				{
				}
				range.RemoveAt(num3);
			}
		}

		private static bool LayerHasParent(GUIX_Layer layer, string parentName)
		{
			Transform val = ((Component)layer).gameObject.transform;
			while ((Object)(object)val != (Object)null)
			{
				if (((Object)val).name == parentName)
				{
					return true;
				}
				val = val.parent;
			}
			return false;
		}
	}
	[HarmonyPatch]
	public static class Patch_CP_Bioscan_Hud
	{
	}
	[HarmonyPatch]
	internal static class Patch_LG_ComputerTerminal_Setup
	{
		private static List<LevelTerminalPlacements> _levelPlacements = new List<LevelTerminalPlacements>();

		public static void Setup()
		{
			_levelPlacements = LevelTerminalPlacements.LoadAll();
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(LG_ComputerTerminal), "Setup")]
		private static void Post_LG_ComputerTerminal_Setup(LG_ComputerTerminal __instance)
		{
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Expected O, but got Unknown
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			ExpeditionInTierData activeExpedition = RundownManager.ActiveExpedition;
			uint mainLayoutId = ((activeExpedition != null) ? activeExpedition.LevelLayoutData : 0u);
			LevelTerminalPlacements levelTerminalPlacements = _levelPlacements.Find((LevelTerminalPlacements ltp) => ltp.MainLevelLayout == mainLayoutId);
			if ((object)levelTerminalPlacements == null || !levelTerminalPlacements.Placements.Any())
			{
				return;
			}
			LG_Zone zone = __instance.SpawnNode.m_zone;
			List<LG_Area> areas = zone.m_areas;
			LG_Layer layer = zone.m_layer;
			List<TerminalPosition> list = levelTerminalPlacements.Placements.Where(delegate(TerminalPosition terminal)
			{
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0034: Unknown result type (might be due to invalid IL or missing references)
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				string obj = $"Zone_{terminal.LocalIndex}";
				eLocalZoneIndex localIndex = zone.LocalIndex;
				if (obj == ((object)(eLocalZoneIndex)(ref localIndex)).ToString())
				{
					string layer2 = terminal.Layer;
					LG_LayerType type = layer.m_type;
					return layer2 == ((object)(LG_LayerType)(ref type)).ToString();
				}
				return false;
			}).ToList();
			if (!list.Any())
			{
				return;
			}
			Enumerator<LG_Area> enumerator = areas.GetEnumerator();
			bool flag = default(bool);
			while (enumerator.MoveNext())
			{
				LG_Area area = enumerator.Current;
				TerminalPosition terminalPosition = list.Find((TerminalPosition terminal) => terminal.HasGeomorphName(((Object)area.m_geomorph).name));
				if ((object)terminalPosition != null)
				{
					Vector3 val = default(Vector3);
					val.x = (float)terminalPosition.Position.X;
					val.y = (float)terminalPosition.Position.Y;
					val.z = (float)terminalPosition.Position.Z;
					Vector3 val2 = val;
					Vector3 val3 = ((Component)area).transform.position + ((Component)area).transform.rotation * val2;
					Quaternion rotation = ((Component)area).transform.rotation;
					float num = (float)((double)((Quaternion)(ref rotation)).eulerAngles.x + terminalPosition.Rotation.X);
					rotation = ((Component)area).transform.rotation;
					float num2 = (float)((double)((Quaternion)(ref rotation)).eulerAngles.y + terminalPosition.Rotation.Y);
					rotation = ((Component)area).transform.rotation;
					Quaternion rotation2 = Quaternion.Euler(num, num2, (float)((double)((Quaternion)(ref rotation)).eulerAngles.z + terminalPosition.Rotation.Z));
					((Component)__instance).transform.position = val3;
					__instance.m_position = val3;
					((Component)__instance).transform.rotation = rotation2;
					ManualLogSource logger = Plugin.Logger;
					BepInExInfoLogInterpolatedStringHandler val4 = new BepInExInfoLogInterpolatedStringHandler(38, 2, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral("Repositioned Terminal ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<string>(((Object)__instance).name);
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" { Position = ");
						((BepInExLogInterpolatedStringHandler)val4).AppendFormatted<Vector3>(val3);
						((BepInExLogInterpolatedStringHandler)val4).AppendLiteral(" }");
					}
					logger.LogInfo(val4);
				}
			}
		}
	}
	[HarmonyPatch]
	public static class Patch_LG_SecurityDoor
	{
		private static List<LevelSecurityDoors> _levelDoors = new List<LevelSecurityDoors>();

		public static readonly Dictionary<(string item, int dimension, int layer, int zone), List<string>> map = new Dictionary<(string, int, int, int), List<string>>();

		private static bool _isReady = false;

		private static readonly List<Action> _deferredActions = new List<Action>();

		private const string Pattern = "\\[(?<ItemName>[A-Z_]+?)_(?:(?:[^\\d_]*)(?<Dimension>\\d+))_(?:(?:[^\\d_]*)(?<Layer>\\d+))_(?:(?:[^\\d_]*)(?<Zone>\\d+))(?:_(?<InstanceIndex>\\d+))?\\]";

		private const string Terminal = "TERMINAL";

		private const string Zone = "ZONE";

		internal static void Setup()
		{
			_levelDoors = LevelSecurityDoors.LoadAll();
			LevelAPI.OnBuildDone += delegate
			{
				BuildMap();
				_isReady = true;
				_deferredActions.ForEach(delegate(Action action)
				{
					action();
				});
				_deferredActions.Clear();
			};
			LevelAPI.OnLevelCleanup += delegate
			{
				_isReady = false;
				_deferredActions.Clear();
				map.Clear();
			};
		}

		public static LevelSecurityDoors? GetDoors()
		{
			ExpeditionInTierData activeExpedition = RundownManager.ActiveExpedition;
			uint mainLayoutId = ((activeExpedition != null) ? activeExpedition.LevelLayoutData : 0u);
			LevelSecurityDoors levelSecurityDoors = _levelDoors.Find((LevelSecurityDoors lsd) => lsd.MainLevelLayout == mainLayoutId);
			if ((object)levelSecurityDoors == null)
			{
				return null;
			}
			if (levelSecurityDoors.Doors.Any())
			{
				return levelSecurityDoors;
			}
			return null;
		}

		public static List<string> Find((string name, int dimension, int layer, int zone) key)
		{
			if (map.TryGetValue(key, out List<string> value))
			{
				return value;
			}
			List<string> list = new List<string>();
			map.Add(key, list);
			return list;
		}

		internal static void BuildMap()
		{
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Expected I4, but got Unknown
			//IL_0123: Expected I4, but got Unknown
			//IL_0123: Expected I4, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected I4, but got Unknown
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Expected I4, but got Unknown
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected I4, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Expected I4, but got Unknown
			//IL_01b3: Expected I4, but got Unknown
			//IL_01b3: Expected I4, but got Unknown
			int num = 0;
			try
			{
				Enumerator<string, iTerminalItem> enumerator = LG_LevelInteractionManager.GetAllTerminalInterfaces().GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<string, iTerminalItem> current = enumerator.Current;
					object obj;
					if (current == null)
					{
						obj = null;
					}
					else
					{
						iTerminalItem value = current.Value;
						obj = ((value != null) ? value.SpawnNode : null);
					}
					if (obj == null)
					{
						continue;
					}
					int num2 = current.Key.LastIndexOf('_');
					if (num2 != -1)
					{
						string text = current.Key.Substring(0, num2);
						string item = current.Key.Substring(num2 + 1);
						if (!(text == "TERMINAL"))
						{
							int item2 = (int)current.Value.SpawnNode.m_dimension.DimensionIndex;
							int item3 = (int)current.Value.SpawnNode.LayerType;
							int item4 = (int)current.Value.SpawnNode.m_zone.LocalIndex;
							Find((text, item2, item3, item4)).Add(item);
							num++;
						}
					}
				}
				Enumerator<LG_Zone> enumerator2 = Builder.CurrentFloor.allZones.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					LG_Zone current2 = enumerator2.Current;
					Find(("ZONE", (int)current2.DimensionIndex, (int)current2.Layer.m_type, (int)current2.LocalIndex)).Add(current2.Alias.ToString());
					num++;
					Enumerator<LG_ComputerTerminal> enumerator3 = current2.TerminalsSpawnedInZone.GetEnumerator();
					while (enumerator3.MoveNext())
					{
						LG_ComputerTerminal current3 = enumerator3.Current;
						if (current3 != null)
						{
							int num3 = current3.m_terminalItem.TerminalItemKey.LastIndexOf('_');
							if (num3 != -1)
							{
								string item5 = current3.m_terminalItem.TerminalItemKey.Substring(num3 + 1);
								Find(("TERMINAL", (int)current2.DimensionIndex, (int)current2.Layer.m_type, (int)current2.LocalIndex)).Add(item5);
								num++;
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = Plugin.Logger;
				bool flag = default(bool);
				BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(32, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Building map failed with error:\n");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<Exception>(ex);
				}
				logger.LogError(val);
			}
		}

		public static string ReplaceAll(string input)
		{
			if (Utility.IsNullOrWhiteSpace(input))
			{
				return input;
			}
			string text = input ?? "";
			foreach (Match item in Regex.Matches(input, "\\[(?<ItemName>[A-Z_]+?)_(?:(?:[^\\d_]*)(?<Dimension>\\d+))_(?:(?:[^\\d_]*)(?<Layer>\\d+))_(?:(?:[^\\d_]*)(?<Zone>\\d+))(?:_(?<InstanceIndex>\\d+))?\\]"))
			{
				if (item.Success && TryFindSerialNumber(item, out string serialStr))
				{
					text = text.Replace(item.Value, serialStr);
				}
			}
			return text;
		}

		public static bool TryFindSerialNumber(Match match, out string serialStr)
		{
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected O, but got Unknown
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			string value = match.Groups["ItemName"].Value;
			int num = int.Parse(match.Groups["Dimension"].Value);
			int num2 = int.Parse(match.Groups["Layer"].Value);
			int num3 = int.Parse(match.Groups["Zone"].Value);
			int num4 = (match.Groups["InstanceIndex"].Success ? int.Parse(match.Groups["InstanceIndex"].Value) : 0);
			bool flag = default(bool);
			if (map.TryGetValue((value, num, num2, num3), out List<string> value2))
			{
				ManualLogSource logger = Plugin.Logger;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(41, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("[SerialLookupManager] Got to first part: ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<List<string>>(value2);
				}
				logger.LogInfo(val);
				if (num4 < value2.Count)
				{
					string value3 = value2[num4];
					serialStr = $"<color=orange>{value}{((value != "ZONE") ? "_" : " ")}{value3}</color>";
					return true;
				}
			}
			serialStr = match.Value;
			ManualLogSource logger2 = Plugin.Logger;
			BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(98, 6, ref flag);
			if (flag)
			{
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("[SerialLookupManager] No match found (map size = ");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(map.Count);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(") for TerminalItem: '");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(value);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("' in (D");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", L");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num2);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(", Z");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num3);
				((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(") at instance #");
				((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<int>(num4);
			}
			logger2.LogError(val2);
			return false;
		}

		public static string PrintMap()
		{
			return GeneralExtensions.Join<string>(map.Select<KeyValuePair<(string, int, int, int), List<string>>, string>((KeyValuePair<(string item, int dimension, int layer, int zone), List<string>> entry) => $"[{entry.Key.item}_{entry.Key.dimension}_{entry.Key.layer}_{entry.Key.zone}] -> [{string.Join(",", entry.Value)}]"), (Func<string, string>)null, "\n");
		}

		[HarmonyPatch(typeof(LG_SecurityDoor_Locks), "OnDoorState")]
		[HarmonyPostfix]
		private static void Post_LG_SecurityDoor_Locks_OnDoorState(LG_SecurityDoor_Locks __instance, pDoorState state, bool isDropinState = false)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Invalid comparison between Unknown and I4
			LG_SecurityDoor_Locks __instance2 = __instance;
			LevelSecurityDoors doors = GetDoors();
			if ((object)doors == null)
			{
				return;
			}
			_ = __instance2.m_door.Gate.DimensionIndex;
			LG_LayerType layer = __instance2.m_door.LinksToLayerType;
			eLocalZoneIndex localIndex = __instance2.m_door.LinkedToZoneData.LocalIndex;
			SecurityDoor door2 = doors.Doors.Find((SecurityDoor door) => door.Layer == (int)layer && door.ZoneNumber == (int)localIndex);
			if (door2?.InteractionMessage == null)
			{
				return;
			}
			eDoorStatus status = state.status;
			if (status - 4 <= 3)
			{
				if (_isReady)
				{
					SetMessage();
				}
				else
				{
					_deferredActions.Add(SetMessage);
				}
			}
			void SetMessage()
			{
				__instance2.m_intOpenDoor.InteractionMessage = ReplaceAll(door2.InteractionMessage);
			}
		}
	}
	[HarmonyPatch]
	internal static class Patch_LG_ZoneJob_CreateExpandFromData
	{
		[HarmonyPatch(typeof(LG_ZoneJob_CreateExpandFromData), "Build")]
		[HarmonyFinalizer]
		public static void Post_LG_ZoneJob_CreateExpandFromData_Build(LG_ZoneJob_CreateExpandFromData __instance, ref Exception? __exception)