using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using ConsoleTables;
using HarmonyLib;
using LethalLevelLoader;
using LethalNetworkAPI;
using Microsoft.CodeAnalysis;
using MrovLib;
using MrovLib.API;
using MrovLib.Compatibility;
using Newtonsoft.Json;
using Steamworks.Data;
using TMPro;
using Unity.Netcode;
using UnityEngine;
using WeatherTweaks.Modules;
using WeatherTweaks.Patches;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyCompany("WeatherTweaks")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("A template for Lethal Company")]
[assembly: AssemblyFileVersion("0.5.0.0")]
[assembly: AssemblyInformationalVersion("0.5.0+fd2bdf34653ded8152b20ee05df720bd6cfff235")]
[assembly: AssemblyProduct("WeatherTweaks")]
[assembly: AssemblyTitle("WeatherTweaks")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.5.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ConsoleTables
{
	public class ConsoleTable
	{
		public static readonly HashSet<Type> NumericTypes = new HashSet<Type>
		{
			typeof(int),
			typeof(double),
			typeof(decimal),
			typeof(long),
			typeof(short),
			typeof(sbyte),
			typeof(byte),
			typeof(ulong),
			typeof(ushort),
			typeof(uint),
			typeof(float)
		};

		public IList<object> Columns { get; }

		public IList<object[]> Rows { get; }

		public ConsoleTableOptions Options { get; }

		public Type[] ColumnTypes { get; private set; }

		public IList<string> Formats { get; private set; }

		public ConsoleTable(params string[] columns)
			: this(new ConsoleTableOptions
			{
				Columns = new List<string>(columns)
			})
		{
		}

		public ConsoleTable(ConsoleTableOptions options)
		{
			Options = options ?? throw new ArgumentNullException("options");
			Rows = new List<object[]>();
			Columns = new List<object>(options.Columns);
		}

		public ConsoleTable AddColumn(IEnumerable<string> names)
		{
			foreach (string name in names)
			{
				Columns.Add(name);
			}
			return this;
		}

		public ConsoleTable AddRow(params object[] values)
		{
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (!Columns.Any())
			{
				throw new Exception("Please set the columns first");
			}
			if (Columns.Count != values.Length)
			{
				throw new Exception($"The number columns in the row ({Columns.Count}) does not match the values ({values.Length})");
			}
			Rows.Add(values);
			return this;
		}

		public ConsoleTable Configure(Action<ConsoleTableOptions> action)
		{
			action(Options);
			return this;
		}

		public static ConsoleTable FromDictionary(Dictionary<string, Dictionary<string, object>> values)
		{
			ConsoleTable consoleTable = new ConsoleTable();
			List<string> list = values.SelectMany((KeyValuePair<string, Dictionary<string, object>> x) => x.Value.Keys).Distinct().ToList();
			list.Insert(0, "");
			consoleTable.AddColumn(list);
			foreach (KeyValuePair<string, Dictionary<string, object>> value2 in values)
			{
				List<object> list2 = new List<object> { value2.Key };
				foreach (string item in list.Skip(1))
				{
					list2.Add(value2.Value.TryGetValue(item, out var value) ? value : "");
				}
				consoleTable.AddRow(list2.Cast<object>().ToArray());
			}
			return consoleTable;
		}

		public static ConsoleTable From<T>(IEnumerable<T> values)
		{
			ConsoleTable consoleTable = new ConsoleTable
			{
				ColumnTypes = GetColumnsType<T>().ToArray()
			};
			List<string> columns = GetColumns<T>().ToList();
			consoleTable.AddColumn(columns);
			foreach (IEnumerable<object> item in values.Select((T value) => columns.Select((string column) => GetColumnValue<T>(value, column))))
			{
				consoleTable.AddRow(item.ToArray());
			}
			return consoleTable;
		}

		public static ConsoleTable From(DataTable dataTable)
		{
			ConsoleTable consoleTable = new ConsoleTable();
			List<string> names = (from DataColumn x in dataTable.Columns
				select x.ColumnName).ToList();
			consoleTable.AddColumn(names);
			foreach (DataRow row in dataTable.Rows)
			{
				string[] array = row.ItemArray.Select((object x) => (x is byte[] inArray) ? Convert.ToBase64String(inArray) : x.ToString()).ToArray();
				object[] values = array;
				consoleTable.AddRow(values);
			}
			return consoleTable;
		}

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			List<int> columnLengths = ColumnLengths();
			List<string> columnAlignment = Enumerable.Range(0, Columns.Count).Select(GetNumberAlignment).ToList();
			string format = (from i in Enumerable.Range(0, Columns.Count)
				select " | {" + i + "," + columnAlignment[i] + columnLengths[i] + "}").Aggregate((string s, string a) => s + a) + " |";
			SetFormats(ColumnLengths(), columnAlignment);
			int val = Math.Max(0, Rows.Any() ? Rows.Max((object[] row) => string.Format(format, row).Length) : 0);
			string text = string.Format(Formats[0], Columns.ToArray());
			int num = Math.Max(val, text.Length);
			List<string> list = Rows.Select((object[] row, int i) => string.Format(Formats[i + 1], row)).ToList();
			string value = " " + string.Join("", Enumerable.Repeat("-", num - 1)) + " ";
			stringBuilder.AppendLine(value);
			stringBuilder.AppendLine(text);
			foreach (string item in list)
			{
				stringBuilder.AppendLine(value);
				stringBuilder.AppendLine(item);
			}
			stringBuilder.AppendLine(value);
			if (Options.EnableCount)
			{
				stringBuilder.AppendLine("");
				stringBuilder.AppendFormat(" Count: {0}", Rows.Count);
			}
			return stringBuilder.ToString();
		}

		private void SetFormats(List<int> columnLengths, List<string> columnAlignment)
		{
			List<object[]> list = new List<object[]>();
			list.Add(Columns.ToArray());
			list.AddRange(Rows);
			Formats = list.Select((object[] d) => Enumerable.Range(0, Columns.Count).Select(delegate(int i)
			{
				string text = d[i]?.ToString() ?? "";
				int num = columnLengths[i] - (GetTextWidth(text) - text.Length);
				return " | {" + i + "," + columnAlignment[i] + num + "}";
			}).Aggregate((string s, string a) => s + a) + " |").ToList();
		}

		public static int GetTextWidth(string value)
		{
			return value?.ToCharArray().Sum((char c) => (c <= '\u007f') ? 1 : 2) ?? 0;
		}

		public string ToMarkDownString()
		{
			return ToMarkDownString('|');
		}

		private string ToMarkDownString(char delimiter)
		{
			StringBuilder builder = new StringBuilder();
			List<int> columnLengths = ColumnLengths();
			Format(columnLengths, delimiter);
			string text = string.Format(Formats[0].TrimStart(), Columns.ToArray());
			List<string> list = Rows.Select((object[] row, int i) => string.Format(Formats[i + 1].TrimStart(), row)).ToList();
			string value = Regex.Replace(text, "[^|]", "-");
			builder.AppendLine(text);
			builder.AppendLine(value);
			list.ForEach(delegate(string row)
			{
				builder.AppendLine(row);
			});
			return builder.ToString();
		}

		public string ToMinimalString()
		{
			return ToMarkDownString('\0');
		}

		public string ToStringAlternative()
		{
			StringBuilder stringBuilder = new StringBuilder();
			string text = string.Format(Formats[0].TrimStart(), Columns.ToArray());
			List<string> list = Rows.Select((object[] row, int i) => string.Format(Formats[i + 1].TrimStart(), row)).ToList();
			string text2 = Regex.Replace(text, "[^| ]", "-");
			string value = text2.Replace("|", "+");
			stringBuilder.AppendLine(value);
			stringBuilder.AppendLine(text);
			foreach (string item in list)
			{
				stringBuilder.AppendLine(value);
				stringBuilder.AppendLine(item);
			}
			stringBuilder.AppendLine(value);
			return stringBuilder.ToString();
		}

		private string Format(List<int> columnLengths, char delimiter = '|')
		{
			List<string> columnAlignment = Enumerable.Range(0, Columns.Count).Select(GetNumberAlignment).ToList();
			SetFormats(columnLengths, columnAlignment);
			string delimiterStr = ((delimiter == '\0') ? string.Empty : delimiter.ToString());
			return ((from i in Enumerable.Range(0, Columns.Count)
				select " " + delimiterStr + " {" + i + "," + columnAlignment[i] + columnLengths[i] + "}").Aggregate((string s, string a) => s + a) + " " + delimiterStr).Trim();
		}

		private string GetNumberAlignment(int i)
		{
			return (Options.NumberAlignment == Alignment.Right && ColumnTypes != null && NumericTypes.Contains(ColumnTypes[i])) ? "" : "-";
		}

		private List<int> ColumnLengths()
		{
			return Columns.Select((object t, int i) => (from x in Rows.Select((object[] x) => x[i]).Union(new object[1] { Columns[i] })
				where x != null
				select x.ToString().ToCharArray().Sum((char c) => (c <= '\u007f') ? 1 : 2)).Max()).ToList();
		}

		public void Write(Format format = ConsoleTables.Format.Default)
		{
			SetFormats(ColumnLengths(), Enumerable.Range(0, Columns.Count).Select(GetNumberAlignment).ToList());
			switch (format)
			{
			case ConsoleTables.Format.Default:
				Options.OutputTo.WriteLine(ToString());
				break;
			case ConsoleTables.Format.MarkDown:
				Options.OutputTo.WriteLine(ToMarkDownString());
				break;
			case ConsoleTables.Format.Alternative:
				Options.OutputTo.WriteLine(ToStringAlternative());
				break;
			case ConsoleTables.Format.Minimal:
				Options.OutputTo.WriteLine(ToMinimalString());
				break;
			default:
				throw new ArgumentOutOfRangeException("format", format, null);
			}
		}

		private static IEnumerable<string> GetColumns<T>()
		{
			return (from x in typeof(T).GetProperties()
				select x.Name).ToArray();
		}

		private static object GetColumnValue<T>(object target, string column)
		{
			return typeof(T).GetProperty(column)?.GetValue(target, null);
		}

		private static IEnumerable<Type> GetColumnsType<T>()
		{
			return (from x in typeof(T).GetProperties()
				select x.PropertyType).ToArray();
		}
	}
	public class ConsoleTableOptions
	{
		public IEnumerable<string> Columns { get; set; } = new List<string>();


		public bool EnableCount { get; set; } = true;


		public Alignment NumberAlignment { get; set; } = Alignment.Left;


		public TextWriter OutputTo { get; set; } = Console.Out;

	}
	public enum Format
	{
		Default,
		MarkDown,
		Alternative,
		Minimal
	}
	public enum Alignment
	{
		Left,
		Right
	}
}
namespace WeatherTweaks
{
	public class ConfigManager
	{
		internal readonly ConfigFile configFile;

		public static ConfigManager Instance { get; private set; }

		public static ConfigEntry<bool> MapScreenPatch { get; private set; }

		public static ConfigEntry<bool> TerminalForcePatch { get; private set; }

		public static ConfigEntry<int> FirstDaySeed { get; private set; }

		public static ConfigEntry<bool> UncertainWeatherEnabled { get; private set; }

		public static ConfigEntry<bool> AlwaysUncertain { get; private set; }

		public static ConfigEntry<bool> AlwaysUnknown { get; private set; }

		public static ConfigEntry<bool> AlwaysClear { get; private set; }

		public static ConfigEntry<float> GameLengthMultiplier { get; private set; }

		public static ConfigEntry<float> GamePlayersMultiplier { get; private set; }

		public static ConfigEntry<float> MaxMultiplier { get; private set; }

		public static ConfigEntry<bool> ScaleDownClearWeather { get; private set; }

		public static ConfigEntry<int> NoneToNoneWeight { get; private set; }

		public static ConfigEntry<int> NoneToRainyWeight { get; private set; }

		public static ConfigEntry<int> NoneToStormyWeight { get; private set; }

		public static ConfigEntry<int> NoneToFloodedWeight { get; private set; }

		public static ConfigEntry<int> NoneToFoggyWeight { get; private set; }

		public static ConfigEntry<int> NoneToEclipsedWeight { get; private set; }

		public static ConfigEntry<int> RainyToNoneWeight { get; private set; }

		public static ConfigEntry<int> RainyToRainyWeight { get; private set; }

		public static ConfigEntry<int> RainyToStormyWeight { get; private set; }

		public static ConfigEntry<int> RainyToFloodedWeight { get; private set; }

		public static ConfigEntry<int> RainyToFoggyWeight { get; private set; }

		public static ConfigEntry<int> RainyToEclipsedWeight { get; private set; }

		public static ConfigEntry<int> StormyToNoneWeight { get; private set; }

		public static ConfigEntry<int> StormyToRainyWeight { get; private set; }

		public static ConfigEntry<int> StormyToStormyWeight { get; private set; }

		public static ConfigEntry<int> StormyToFloodedWeight { get; private set; }

		public static ConfigEntry<int> StormyToFoggyWeight { get; private set; }

		public static ConfigEntry<int> StormyToEclipsedWeight { get; private set; }

		public static ConfigEntry<int> FloodedToNoneWeight { get; private set; }

		public static ConfigEntry<int> FloodedToRainyWeight { get; private set; }

		public static ConfigEntry<int> FloodedToStormyWeight { get; private set; }

		public static ConfigEntry<int> FloodedToFloodedWeight { get; private set; }

		public static ConfigEntry<int> FloodedToFoggyWeight { get; private set; }

		public static ConfigEntry<int> FloodedToEclipsedWeight { get; private set; }

		public static ConfigEntry<int> FoggyToNoneWeight { get; private set; }

		public static ConfigEntry<int> FoggyToRainyWeight { get; private set; }

		public static ConfigEntry<int> FoggyToStormyWeight { get; private set; }

		public static ConfigEntry<int> FoggyToFloodedWeight { get; private set; }

		public static ConfigEntry<int> FoggyToFoggyWeight { get; private set; }

		public static ConfigEntry<int> FoggyToEclipsedWeight { get; private set; }

		public static ConfigEntry<int> EclipsedToNoneWeight { get; private set; }

		public static ConfigEntry<int> EclipsedToRainyWeight { get; private set; }

		public static ConfigEntry<int> EclipsedToStormyWeight { get; private set; }

		public static ConfigEntry<int> EclipsedToFloodedWeight { get; private set; }

		public static ConfigEntry<int> EclipsedToFoggyWeight { get; private set; }

		public static ConfigEntry<int> EclipsedToEclipsedWeight { get; private set; }

		public static int NoneWeightSum { get; private set; }

		public static int RainyWeightSum { get; private set; }

		public static int StormyWeightSum { get; private set; }

		public static int FloodedWeightSum { get; private set; }

		public static int FoggyWeightSum { get; private set; }

		public static int EclipsedWeightSum { get; private set; }

		public static Dictionary<LevelWeatherType, int> NoneWeights { get; private set; }

		public static Dictionary<LevelWeatherType, int> RainyWeights { get; private set; }

		public static Dictionary<LevelWeatherType, int> StormyWeights { get; private set; }

		public static Dictionary<LevelWeatherType, int> FloodedWeights { get; private set; }

		public static Dictionary<LevelWeatherType, int> FoggyWeights { get; private set; }

		public static Dictionary<LevelWeatherType, int> EclipsedWeights { get; private set; }

		public static Dictionary<LevelWeatherType, Dictionary<LevelWeatherType, int>> Weights { get; private set; }

		public static void Init(ConfigFile config)
		{
			Instance = new ConfigManager(config);
		}

		private ConfigManager(ConfigFile config)
		{
			configFile = config;
			MapScreenPatch = configFile.Bind<bool>("0> General", "MapScreenPatch", true, "Enable map screen patch (weather in top row)");
			TerminalForcePatch = configFile.Bind<bool>("0> General", "TerminalForcePatch", true, "Disable patching terminal weather formatting (for compatibility with vanilla game)");
			UncertainWeatherEnabled = configFile.Bind<bool>("1> Uncertain weather", "UncertainWeatherEnabled", true, "Enable uncertain weather mechanic");
			MaxMultiplier = configFile.Bind<float>("2> Multipliers", "MaxMultiplier", 0.8f, "Maximum difficulty multiplier (between 0 and 1)");
			ScaleDownClearWeather = configFile.Bind<bool>("2> Multipliers", "ScaleDownClearWeather", true, "Scale down clear weather's weight based on planet's available random weathers to match % chance ");
			GameLengthMultiplier = configFile.Bind<float>("2a> Difficulty multipliers", "GameLengthMultiplier", 0.05f, "Difficulty multiplier - game length (quotas done)");
			GamePlayersMultiplier = configFile.Bind<float>("2a> Difficulty multipliers", "GamePlayersMultiplier", 0.01f, "Difficulty multiplier - players amount");
			FirstDaySeed = configFile.Bind<int>("3> First day", "FirstDaySeed", 0, "Seed for the first day's weather");
			AlwaysUncertain = configFile.Bind<bool>("4> Special modes", "AlwaysUncertain", false, "Always make weather uncertain");
			AlwaysUnknown = configFile.Bind<bool>("4> Special modes", "AlwaysUnknown", false, "Always make weather unknown");
			AlwaysClear = configFile.Bind<bool>("4> Special modes", "AlwaysClear", false, "Always make weather clear - good for testing");
			NoneToNoneWeight = configFile.Bind<int>("Weights > Clear", "NoneToNoneWeight", 80, "Weight for changing from none to none");
			NoneToRainyWeight = configFile.Bind<int>("Weights > Clear", "NoneToRainyWeight", 50, "Weight for changing from none to rainy");
			NoneToStormyWeight = configFile.Bind<int>("Weights > Clear", "NoneToStormyWeight", 35, "Weight for changing from none to stormy");
			NoneToFloodedWeight = configFile.Bind<int>("Weights > Clear", "NoneToFloodedWeight", 10, "Weight for changing from none to flooded");
			NoneToFoggyWeight = configFile.Bind<int>("Weights > Clear", "NoneToFoggyWeight", 20, "Weight for changing from none to foggy");
			NoneToEclipsedWeight = configFile.Bind<int>("Weights > Clear", "NoneToEclipsedWeight", 5, "Weight for changing from none to eclipsed");
			RainyToNoneWeight = configFile.Bind<int>("Weights > Rainy", "RainyToNoneWeight", 50, "Weight for changing from rainy to none");
			RainyToRainyWeight = configFile.Bind<int>("Weights > Rainy", "RainyToRainyWeight", 30, "Weight for changing from rainy to rainy");
			RainyToStormyWeight = configFile.Bind<int>("Weights > Rainy", "RainyToStormyWeight", 20, "Weight for changing from rainy to stormy");
			RainyToFloodedWeight = configFile.Bind<int>("Weights > Rainy", "RainyToFloodedWeight", 15, "Weight for changing from rainy to flooded");
			RainyToFoggyWeight = configFile.Bind<int>("Weights > Rainy", "RainyToFoggyWeight", 25, "Weight for changing from rainy to foggy");
			RainyToEclipsedWeight = configFile.Bind<int>("Weights > Rainy", "RainyToEclipsedWeight", 10, "Weight for changing from rainy to eclipsed");
			StormyToNoneWeight = configFile.Bind<int>("Weights > Stormy", "StormyToNoneWeight", 80, "Weight for changing from stormy to none");
			StormyToRainyWeight = configFile.Bind<int>("Weights > Stormy", "StormyToRainyWeight", 55, "Weight for changing from stormy to rainy");
			StormyToStormyWeight = configFile.Bind<int>("Weights > Stormy", "StormyToStormyWeight", 5, "Weight for changing from stormy to stormy");
			StormyToFloodedWeight = configFile.Bind<int>("Weights > Stormy", "StormyToFloodedWeight", 60, "Weight for changing from stormy to flooded");
			StormyToFoggyWeight = configFile.Bind<int>("Weights > Stormy", "StormyToFoggyWeight", 10, "Weight for changing from stormy to foggy");
			StormyToEclipsedWeight = configFile.Bind<int>("Weights > Stormy", "StormyToEclipsedWeight", 40, "Weight for changing from stormy to eclipsed");
			FloodedToNoneWeight = configFile.Bind<int>("Weights > Flooded", "FloodedToNoneWeight", 80, "Weight for changing from flooded to none");
			FloodedToRainyWeight = configFile.Bind<int>("Weights > Flooded", "FloodedToRainyWeight", 30, "Weight for changing from flooded to rainy");
			FloodedToStormyWeight = configFile.Bind<int>("Weights > Flooded", "FloodedToStormyWeight", 25, "Weight for changing from flooded to stormy");
			FloodedToFloodedWeight = configFile.Bind<int>("Weights > Flooded", "FloodedToFloodedWeight", 5, "Weight for changing from flooded to flooded");
			FloodedToFoggyWeight = configFile.Bind<int>("Weights > Flooded", "FloodedToFoggyWeight", 30, "Weight for changing from flooded to foggy");
			FloodedToEclipsedWeight = configFile.Bind<int>("Weights > Flooded", "FloodedToEclipsedWeight", 20, "Weight for changing from flooded to eclipsed");
			FoggyToNoneWeight = configFile.Bind<int>("Weights > Foggy", "FoggyToNoneWeight", 100, "Weight for changing from foggy to none");
			FoggyToRainyWeight = configFile.Bind<int>("Weights > Foggy", "FoggyToRainyWeight", 30, "Weight for changing from foggy to rainy");
			FoggyToStormyWeight = configFile.Bind<int>("Weights > Foggy", "FoggyToStormyWeight", 25, "Weight for changing from foggy to stormy");
			FoggyToFloodedWeight = configFile.Bind<int>("Weights > Foggy", "FoggyToFloodedWeight", 5, "Weight for changing from foggy to flooded");
			FoggyToFoggyWeight = configFile.Bind<int>("Weights > Foggy", "FoggyToFoggyWeight", 15, "Weight for changing from foggy to foggy");
			FoggyToEclipsedWeight = configFile.Bind<int>("Weights > Foggy", "FoggyToEclipsedWeight", 10, "Weight for changing from foggy to eclipsed");
			EclipsedToNoneWeight = configFile.Bind<int>("Weights > Eclipsed", "EclipsedToNoneWeight", 150, "Weight for changing from eclipsed to none");
			EclipsedToRainyWeight = configFile.Bind<int>("Weights > Eclipsed", "EclipsedToRainyWeight", 20, "Weight for changing from eclipsed to rainy");
			EclipsedToStormyWeight = configFile.Bind<int>("Weights > Eclipsed", "EclipsedToStormyWeight", 8, "Weight for changing from eclipsed to stormy");
			EclipsedToFloodedWeight = configFile.Bind<int>("Weights > Eclipsed", "EclipsedToFloodedWeight", 10, "Weight for changing from eclipsed to flooded");
			EclipsedToFoggyWeight = configFile.Bind<int>("Weights > Eclipsed", "EclipsedToFoggyWeight", 30, "Weight for changing from eclipsed to foggy");
			EclipsedToEclipsedWeight = configFile.Bind<int>("Weights > Eclipsed", "EclipsedToEclipsedWeight", 5, "Weight for changing from eclipsed to eclipsed");
			NoneWeightSum = NoneToNoneWeight.Value + NoneToRainyWeight.Value + NoneToStormyWeight.Value + NoneToFloodedWeight.Value + NoneToFoggyWeight.Value + NoneToEclipsedWeight.Value;
			RainyWeightSum = RainyToNoneWeight.Value + RainyToRainyWeight.Value + RainyToStormyWeight.Value + RainyToFloodedWeight.Value + RainyToFoggyWeight.Value + RainyToEclipsedWeight.Value;
			StormyWeightSum = StormyToNoneWeight.Value + StormyToRainyWeight.Value + StormyToStormyWeight.Value + StormyToFloodedWeight.Value + StormyToFoggyWeight.Value + StormyToEclipsedWeight.Value;
			FloodedWeightSum = FloodedToNoneWeight.Value + FloodedToRainyWeight.Value + FloodedToStormyWeight.Value + FloodedToFloodedWeight.Value + FloodedToFoggyWeight.Value + FloodedToEclipsedWeight.Value;
			FoggyWeightSum = FoggyToNoneWeight.Value + FoggyToRainyWeight.Value + FoggyToStormyWeight.Value + FoggyToFloodedWeight.Value + FoggyToFoggyWeight.Value + FoggyToEclipsedWeight.Value;
			EclipsedWeightSum = EclipsedToNoneWeight.Value + EclipsedToRainyWeight.Value + EclipsedToStormyWeight.Value + EclipsedToFloodedWeight.Value + EclipsedToFoggyWeight.Value + EclipsedToEclipsedWeight.Value;
			NoneWeights = new Dictionary<LevelWeatherType, int>
			{
				{
					(LevelWeatherType)(-1),
					NoneToNoneWeight.Value
				},
				{
					(LevelWeatherType)1,
					NoneToRainyWeight.Value
				},
				{
					(LevelWeatherType)2,
					NoneToStormyWeight.Value
				},
				{
					(LevelWeatherType)4,
					NoneToFloodedWeight.Value
				},
				{
					(LevelWeatherType)3,
					NoneToFoggyWeight.Value
				},
				{
					(LevelWeatherType)5,
					NoneToEclipsedWeight.Value
				}
			};
			RainyWeights = new Dictionary<LevelWeatherType, int>
			{
				{
					(LevelWeatherType)(-1),
					RainyToNoneWeight.Value
				},
				{
					(LevelWeatherType)1,
					RainyToRainyWeight.Value
				},
				{
					(LevelWeatherType)2,
					RainyToStormyWeight.Value
				},
				{
					(LevelWeatherType)4,
					RainyToFloodedWeight.Value
				},
				{
					(LevelWeatherType)3,
					RainyToFoggyWeight.Value
				},
				{
					(LevelWeatherType)5,
					RainyToEclipsedWeight.Value
				}
			};
			StormyWeights = new Dictionary<LevelWeatherType, int>
			{
				{
					(LevelWeatherType)(-1),
					StormyToNoneWeight.Value
				},
				{
					(LevelWeatherType)1,
					StormyToRainyWeight.Value
				},
				{
					(LevelWeatherType)2,
					StormyToStormyWeight.Value
				},
				{
					(LevelWeatherType)4,
					StormyToFloodedWeight.Value
				},
				{
					(LevelWeatherType)3,
					StormyToFoggyWeight.Value
				},
				{
					(LevelWeatherType)5,
					StormyToEclipsedWeight.Value
				}
			};
			FloodedWeights = new Dictionary<LevelWeatherType, int>
			{
				{
					(LevelWeatherType)(-1),
					FloodedToNoneWeight.Value
				},
				{
					(LevelWeatherType)1,
					FloodedToRainyWeight.Value
				},
				{
					(LevelWeatherType)2,
					FloodedToStormyWeight.Value
				},
				{
					(LevelWeatherType)4,
					FloodedToFloodedWeight.Value
				},
				{
					(LevelWeatherType)3,
					FloodedToFoggyWeight.Value
				},
				{
					(LevelWeatherType)5,
					FloodedToEclipsedWeight.Value
				}
			};
			FoggyWeights = new Dictionary<LevelWeatherType, int>
			{
				{
					(LevelWeatherType)(-1),
					FoggyToNoneWeight.Value
				},
				{
					(LevelWeatherType)1,
					FoggyToRainyWeight.Value
				},
				{
					(LevelWeatherType)2,
					FoggyToStormyWeight.Value
				},
				{
					(LevelWeatherType)4,
					FoggyToFloodedWeight.Value
				},
				{
					(LevelWeatherType)3,
					FoggyToFoggyWeight.Value
				},
				{
					(LevelWeatherType)5,
					FoggyToEclipsedWeight.Value
				}
			};
			EclipsedWeights = new Dictionary<LevelWeatherType, int>
			{
				{
					(LevelWeatherType)(-1),
					EclipsedToNoneWeight.Value
				},
				{
					(LevelWeatherType)1,
					EclipsedToRainyWeight.Value
				},
				{
					(LevelWeatherType)2,
					EclipsedToStormyWeight.Value
				},
				{
					(LevelWeatherType)4,
					EclipsedToFloodedWeight.Value
				},
				{
					(LevelWeatherType)3,
					EclipsedToFoggyWeight.Value
				},
				{
					(LevelWeatherType)5,
					EclipsedToEclipsedWeight.Value
				}
			};
			Weights = new Dictionary<LevelWeatherType, Dictionary<LevelWeatherType, int>>
			{
				{
					(LevelWeatherType)(-1),
					NoneWeights
				},
				{
					(LevelWeatherType)1,
					RainyWeights
				},
				{
					(LevelWeatherType)2,
					StormyWeights
				},
				{
					(LevelWeatherType)4,
					FloodedWeights
				},
				{
					(LevelWeatherType)3,
					FoggyWeights
				},
				{
					(LevelWeatherType)5,
					EclipsedWeights
				}
			};
		}
	}
	public static class DisplayTable
	{
		public static void DisplayWeathersTable()
		{
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			ConsoleTable consoleTable = new ConsoleTable("Planet", "Weather");
			List<SelectableLevel> gameLevels = Variables.GetGameLevels();
			foreach (SelectableLevel item in gameLevels)
			{
				consoleTable.AddRow(item.PlanetName, item.currentWeather);
			}
			Plugin.logger.LogInfo((object)("Currently set weathers: \n" + consoleTable.ToMinimalString()));
		}
	}
	internal class GameInteraction
	{
		internal static void SetWeather(Dictionary<string, LevelWeatherType> weatherData)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			List<SelectableLevel> gameLevels = Variables.GetGameLevels();
			foreach (SelectableLevel item in gameLevels)
			{
				string planetName = item.PlanetName;
				if (weatherData.ContainsKey(planetName))
				{
					item.currentWeather = weatherData[planetName];
				}
				else
				{
					Plugin.logger.LogWarning((object)("Weather data for " + planetName + " somehow not found, skipping"));
				}
			}
			StartOfRound.Instance.SetMapScreenInfoToCurrentLevel();
		}
	}
	internal class NetworkedConfig
	{
		public static LethalNetworkVariable<string> currentWeatherSynced = new LethalNetworkVariable<string>("previousWeather");

		public static LethalNetworkVariable<string> currentWeatherStringsSynced = new LethalNetworkVariable<string>("previousWeatherStrings");

		public static void Init()
		{
			currentWeatherSynced.OnValueChanged += WeatherDataReceived;
			currentWeatherStringsSynced.OnValueChanged += WeatherDisplayDataReceived;
		}

		public static void WeatherDataReceived(string weatherData)
		{
			Dictionary<string, LevelWeatherType> dictionary = JsonConvert.DeserializeObject<Dictionary<string, LevelWeatherType>>(weatherData);
			if (dictionary != null && !((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				Plugin.logger.LogInfo((object)"Received weather data from server, applying");
				Plugin.logger.LogDebug((object)("Received data: " + weatherData));
				GameInteraction.SetWeather(dictionary);
				DisplayTable.DisplayWeathersTable();
				StartOfRound.Instance.SetMapScreenInfoToCurrentLevel();
			}
		}

		public static void WeatherDisplayDataReceived(string weatherData)
		{
			Dictionary<string, string> dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(weatherData);
			if (dictionary != null && !((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				Plugin.logger.LogInfo((object)"Received weather display data from server, applying");
				Plugin.logger.LogDebug((object)("Received data: " + weatherData));
				UncertainWeather.uncertainWeathers = dictionary;
				StartOfRound.Instance.SetMapScreenInfoToCurrentLevel();
			}
		}

		public static void SetWeather(Dictionary<string, LevelWeatherType> previousWeather)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			string text = JsonConvert.SerializeObject((object)previousWeather, (Formatting)0, new JsonSerializerSettings
			{
				ReferenceLoopHandling = (ReferenceLoopHandling)1
			});
			currentWeatherSynced.Value = text;
			Plugin.logger.LogInfo((object)("Set weather data on server: " + text));
		}

		public static void SetDisplayWeather(Dictionary<string, string> uncertainWeathers)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Expected O, but got Unknown
			string text = JsonConvert.SerializeObject((object)uncertainWeathers, (Formatting)0, new JsonSerializerSettings
			{
				ReferenceLoopHandling = (ReferenceLoopHandling)1
			});
			currentWeatherStringsSynced.Value = text;
			Plugin.logger.LogInfo((object)("Set weather display data on server: " + text));
		}
	}
	public class GeneralImprovementsWeather
	{
		private static Type type;

		private static FieldInfo weatherMonitorsField;

		private static FieldInfo fancyMonitorsField;

		private static int frame = 0;

		internal static ManualLogSource logger = Logger.CreateLogSource("WeatherTweaks GI");

		public static void Init()
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			string key = "ShaosilGaming.GeneralImprovements";
			Dictionary<string, PluginInfo> pluginInfos = Chainloader.PluginInfos;
			if (pluginInfos.ContainsKey(key))
			{
				string text = "GeneralImprovements.Utilities";
				string text2 = "MonitorsHelper";
				Assembly assembly = ((object)Chainloader.PluginInfos[key].Instance).GetType().Assembly;
				type = assembly.GetType(text + "." + text2);
				if (type != null)
				{
					Plugin.logger.LogWarning((object)"GeneralImprovements found, patching weather displays");
					MethodInfo method = type.GetMethod("UpdateGenericTextList", BindingFlags.Static | BindingFlags.NonPublic);
					weatherMonitorsField = type.GetField("_weatherMonitorTexts", BindingFlags.Static | BindingFlags.NonPublic);
					fancyMonitorsField = type.GetField("_fancyWeatherMonitorTexts", BindingFlags.Static | BindingFlags.NonPublic);
					Harmony val = new Harmony("Weathertweaks.GIPatch");
					HarmonyMethod val2 = new HarmonyMethod(typeof(GeneralImprovementsWeather).GetMethod("TextPatch", BindingFlags.Static | BindingFlags.Public));
					val.Patch((MethodBase)method, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				}
			}
		}

		public static void TextPatch(List<TextMeshProUGUI> textList, ref string text)
		{
			bool isWeatherMonitor = false;
			List<TextMeshProUGUI> weathermonitors = weatherMonitorsField.GetValue(null) as List<TextMeshProUGUI>;
			List<TextMeshProUGUI> fancymonitors = fancyMonitorsField.GetValue(null) as List<TextMeshProUGUI>;
			CollectionExtensions.Do<TextMeshProUGUI>((IEnumerable<TextMeshProUGUI>)textList, (Action<TextMeshProUGUI>)delegate(TextMeshProUGUI monitor)
			{
				if (!((Object)(object)monitor == (Object)null) && (weathermonitors.Contains(monitor) || fancymonitors.Contains(monitor)))
				{
					isWeatherMonitor = true;
				}
			});
			if (!isWeatherMonitor)
			{
				return;
			}
			string planetCurrentWeather = Variables.GetPlanetCurrentWeather(StartOfRound.Instance.currentLevel);
			bool flag = ((object)(LevelWeatherType)(ref StartOfRound.Instance.currentLevel.currentWeather)).ToString() != planetCurrentWeather;
			if (text.Contains("WEATHER:\n"))
			{
				string text2 = "WEATHER:\n" + planetCurrentWeather;
				logger.LogDebug((object)("Changing " + text.Replace("\n", " ") + " to " + text2.Replace("\n", " ")));
				text = text2;
			}
			else if (flag)
			{
				text = "???????????????????????????????????";
				text = Regex.Replace(text, "[?]", (Match m) => (frame++ % 20 == 0) ? " " : m.Value);
				text = Regex.Replace(text, ".{8}", "$0\n");
				text = Regex.Replace(text, "(?<=\\n.*\\n.*\\n.*\\n).+", "");
				frame++;
				if (frame == 20)
				{
					frame = 0;
				}
			}
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public static class SetMapScreenInfoToCurrentLevelPatch
	{
		[HarmonyPatch("SetMapScreenInfoToCurrentLevel")]
		[HarmonyPostfix]
		[HarmonyPriority(500)]
		[HarmonyBefore(new string[] { "com.zealsprince.malfunctions" })]
		internal static void GameMethodPatch(ref TextMeshProUGUI ___screenLevelDescription, ref SelectableLevel ___currentLevel)
		{
			if (ConfigManager.MapScreenPatch.Value)
			{
				string planetCurrentWeather = Variables.GetPlanetCurrentWeather(___currentLevel);
				Plugin.logger.LogDebug((object)("Weather condition: " + planetCurrentWeather));
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append("ORBITING: " + ___currentLevel.PlanetName + "\n");
				stringBuilder.Append("WEATHER: " + GetHexColor(planetCurrentWeather) + planetCurrentWeather + "</color>\n");
				stringBuilder.Append(___currentLevel.LevelDescription ?? "");
				((TMP_Text)___screenLevelDescription).text = stringBuilder.ToString();
			}
		}

		private static LevelWeatherType ResolveWeatherStringToType(string inputWeather)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			if (inputWeather.Contains("Eclipsed"))
			{
				return (LevelWeatherType)5;
			}
			if (inputWeather.Contains("Flooded"))
			{
				return (LevelWeatherType)4;
			}
			if (inputWeather.Contains("Stormy"))
			{
				return (LevelWeatherType)2;
			}
			if (inputWeather.Contains("Foggy"))
			{
				return (LevelWeatherType)3;
			}
			if (inputWeather.Contains("Rainy"))
			{
				return (LevelWeatherType)1;
			}
			if (inputWeather.Contains("DustClouds"))
			{
				return (LevelWeatherType)0;
			}
			return (LevelWeatherType)(-1);
		}

		private static string GetHexColor(string currentWeather)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//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_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected I4, but got Unknown
			if (currentWeather == "[UNKNOWN]")
			{
				return "<color=#4a4a4a>";
			}
			LevelWeatherType val = ResolveWeatherStringToType(currentWeather);
			if (1 == 0)
			{
			}
			string text;
			switch (val - -1)
			{
			case 0:
			case 1:
				text = "69FF6B";
				break;
			case 2:
			case 4:
				text = "FFDC00";
				break;
			case 3:
			case 5:
				text = "FF9300";
				break;
			case 6:
				text = "FF0000";
				break;
			default:
				text = "FFFFFF";
				break;
			}
			if (1 == 0)
			{
			}
			string text2 = text;
			return "<color=#" + text2 + ">";
		}
	}
	[HarmonyPatch(typeof(StartOfRound))]
	public static class SetPlanetsWeatherPatch
	{
		[HarmonyPatch("SetPlanetsWeather")]
		[HarmonyPrefix]
		private static bool GameMethodPatch(int connectedPlayersOnServer, StartOfRound __instance)
		{
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			Plugin.logger.LogMessage((object)"SetPlanetsWeather called.");
			if ((Object)(object)__instance == (Object)null)
			{
				Plugin.logger.LogWarning((object)"Instance is null");
				return true;
			}
			List<SelectableLevel> gameLevels = Variables.GetGameLevels();
			if (gameLevels == null)
			{
				Plugin.logger.LogWarning((object)"Levels are null");
				return true;
			}
			bool hasValue = GameNetworkManager.Instance.currentLobby.HasValue;
			Lobby valueOrDefault;
			if (((NetworkBehaviour)__instance).IsHost)
			{
				Dictionary<string, LevelWeatherType> weather = WeatherCalculation.NewWeathers(__instance);
				GameInteraction.SetWeather(weather);
				NetworkedConfig.SetWeather(weather);
				Dictionary<string, string> displayWeather = UncertainWeather.GenerateUncertainty();
				NetworkedConfig.SetDisplayWeather(displayWeather);
				__instance.SetMapScreenInfoToCurrentLevel();
				if (hasValue)
				{
					Lobby? currentLobby = GameNetworkManager.Instance.currentLobby;
					if (currentLobby.HasValue)
					{
						valueOrDefault = currentLobby.GetValueOrDefault();
						((Lobby)(ref valueOrDefault)).SetData("WeatherTweaks", "true");
					}
				}
			}
			else
			{
				Plugin.logger.LogMessage((object)"Not a host");
				if (hasValue)
				{
					Lobby? currentLobby = GameNetworkManager.Instance.currentLobby;
					object obj;
					if (!currentLobby.HasValue)
					{
						obj = null;
					}
					else
					{
						valueOrDefault = currentLobby.GetValueOrDefault();
						obj = ((Lobby)(ref valueOrDefault)).GetData("WeatherTweaks");
					}
					if (obj == null)
					{
						Plugin.logger.LogMessage((object)"Mod not detected on host, falling back to vanilla");
						return true;
					}
					Plugin.logger.LogMessage((object)"Detected mod on host, waiting for weather data");
				}
				Plugin.logger.LogDebug((object)("Current data: " + NetworkedConfig.currentWeatherSynced.Value));
			}
			return false;
		}

		[HarmonyPatch("SetPlanetsWeather")]
		[HarmonyPostfix]
		private static void DisplayCurrentWeathers()
		{
			DisplayTable.DisplayWeathersTable();
		}
	}
	[HarmonyPatch(typeof(Terminal))]
	public static class TextPostProcessPatch
	{
		internal static ManualLogSource logger = Logger.CreateLogSource("WeatherTweaks Terminal");

		[HarmonyPatch("TextPostProcess")]
		[HarmonyPrefix]
		[HarmonyPriority(700)]
		private static bool PatchGameMethod(ref string modifiedDisplayText, TerminalNode node)
		{
			if (ConfigManager.TerminalForcePatch.Value)
			{
				logger.LogInfo((object)"Removing terminal weather formatting");
				if (node.buyRerouteToMoon == -2)
				{
					logger.LogDebug((object)"buyRerouteToMoon == -2");
					Regex regex = new Regex("\\ It is (\\n)*currently.+\\[currentPlanetTime].+");
					if (regex.IsMatch(modifiedDisplayText))
					{
						modifiedDisplayText = regex.Replace(modifiedDisplayText, "");
					}
				}
				if (((Object)node).name == "MoonsCatalogue")
				{
					Regex regex2 = new Regex("\\[planetTime\\]");
					modifiedDisplayText = regex2.Replace(modifiedDisplayText, "");
				}
			}
			return true;
		}
	}
	[BepInPlugin("WeatherTweaks", "WeatherTweaks", "0.5.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource logger;

		private void Awake()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			logger = ((BaseUnityPlugin)this).Logger;
			Harmony val = new Harmony("WeatherTweaks");
			val.PatchAll();
			NetworkedConfig.Init();
			ConfigManager.Init(((BaseUnityPlugin)this).Config);
			UncertainWeather.Init();
			GeneralImprovementsWeather.Init();
			if (Chainloader.PluginInfos.ContainsKey("imabatby.lethallevelloader"))
			{
				LLL.Init();
			}
			if (Chainloader.PluginInfos.ContainsKey("com.zealsprince.malfunctions"))
			{
				Malfunctions.Init();
			}
			if (Chainloader.PluginInfos.ContainsKey("xxxstoner420bongmasterxxx.open_monitors"))
			{
				OpenMonitorsPatch.Init();
			}
			logger.LogInfo((object)"\r\n                  .::.                  \r\n                  :==:                  \r\n         :-.      :==:      .-:         \r\n        .-==-.    .::.    .-===.        \r\n          .-=-  .:----:.  -==.          \r\n              -==========-              \r\n             ==============             \r\n               .-==========- :-----     \r\n         :-==-:. .=========- :-----     \r\n       .========:   .-=====             \r\n       ============-. :==-              \r\n       -=============. .  -==.          \r\n        :-==========:     .-==-.        \r\n            ......          .-:         ");
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin WeatherTweaks is loaded!");
		}
	}
	internal class UncertainTypes
	{
		public class Uncertain : Types.UncertainWeatherType
		{
			public Uncertain()
				: base("Uncertain")
			{
			}

			public override string CreateUncertaintyString(SelectableLevel level, Random random)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				LevelWeatherType weather = level.currentWeather;
				List<RandomWeatherWithVariables> list = level.randomWeathers.Where((RandomWeatherWithVariables w) => w.weatherType != weather).ToList();
				if (list.Count == 0)
				{
					return ((object)(LevelWeatherType)(ref weather)).ToString();
				}
				RandomWeatherWithVariables val = list[random.Next(list.Count)];
				if (random.Next(0, 3) == 0)
				{
					return $"{val.weatherType}?";
				}
				return $"{weather}?";
			}
		}

		public class Uncertain5050 : Types.UncertainWeatherType
		{
			public Uncertain5050()
				: base("Uncertain5050")
			{
			}

			public override string CreateUncertaintyString(SelectableLevel level, Random random)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a3: 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_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				LevelWeatherType weather = level.currentWeather;
				List<RandomWeatherWithVariables> list = level.randomWeathers.Where((RandomWeatherWithVariables w) => w.weatherType != weather).ToList();
				if (list.Count == 0)
				{
					return ((object)(LevelWeatherType)(ref weather)).ToString();
				}
				RandomWeatherWithVariables val = list[random.Next(list.Count)];
				if (random.Next(0, 2) == 0)
				{
					return $"{weather}/{val.weatherType}";
				}
				return $"{val.weatherType}/{weather}";
			}
		}

		public class Unknown : Types.UncertainWeatherType
		{
			public Unknown()
				: base("Unknown")
			{
			}

			public override string CreateUncertaintyString(SelectableLevel level, Random random)
			{
				return "[UNKNOWN]";
			}
		}
	}
	internal class UncertainWeather
	{
		public static Dictionary<string, string> uncertainWeathers = new Dictionary<string, string>();

		public static List<Types.UncertainWeatherType> uncertainWeatherTypes = new List<Types.UncertainWeatherType>();

		public static void Init()
		{
			Plugin.logger.LogInfo((object)"UncertainWeather initialized.");
			uncertainWeatherTypes = new List<Types.UncertainWeatherType>(3)
			{
				new UncertainTypes.Uncertain(),
				new UncertainTypes.Uncertain5050(),
				new UncertainTypes.Unknown()
			};
		}

		public static Dictionary<string, string> GenerateUncertainty()
		{
			uncertainWeathers.Clear();
			if (!ConfigManager.UncertainWeatherEnabled.Value || !ConfigManager.MapScreenPatch.Value || !ConfigManager.TerminalForcePatch.Value)
			{
				Plugin.logger.LogInfo((object)"Uncertain weathers are disabled.");
				return uncertainWeathers;
			}
			if (StartOfRound.Instance.gameStats.daysSpent == 0 && !ConfigManager.AlwaysUncertain.Value && !ConfigManager.AlwaysUnknown.Value)
			{
				Plugin.logger.LogInfo((object)"It's the first day, no uncertainty will be generated.");
				return uncertainWeathers;
			}
			Plugin.logger.LogInfo((object)"GenerateUncertainty called.");
			StartOfRound instance = StartOfRound.Instance;
			Random random = new Random(instance.randomMapSeed + 31);
			int num = Mathf.Clamp((int)((double)Mathf.Clamp(instance.planetsWeatherRandomCurve.Evaluate((float)random.NextDouble()) * 0.4f, 0f, 1f) * (double)Variables.GameLevels.Count), 1, Variables.GameLevels.Count - 2);
			if (ConfigManager.AlwaysUncertain.Value || ConfigManager.AlwaysUnknown.Value)
			{
				num = Variables.GameLevels.Count;
			}
			Plugin.logger.LogDebug((object)$"howManyPlanetsUncertain: {num}");
			List<SelectableLevel> list = new List<SelectableLevel>();
			for (int i = 0; i < num; i++)
			{
				SelectableLevel item = Variables.GameLevels[random.Next(Variables.GameLevels.Count)];
				if (!list.Contains(item))
				{
					list.Add(item);
				}
				else
				{
					i--;
				}
			}
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			List<Types.UncertainWeatherType> list2 = new List<Types.UncertainWeatherType>();
			foreach (Types.UncertainWeatherType uncertainWeatherType in uncertainWeatherTypes)
			{
				if (uncertainWeatherType.Enabled.Value)
				{
					list2.Add(uncertainWeatherType);
				}
			}
			if (ConfigManager.AlwaysUnknown.Value)
			{
				Plugin.logger.LogDebug((object)"Setting possible types to only unknown.");
				list2 = new List<Types.UncertainWeatherType>(1)
				{
					new UncertainTypes.Unknown()
				};
			}
			Plugin.logger.LogDebug((object)$"uncertainTypes: {list2.Count}");
			if (list2.Count == 0)
			{
				Plugin.logger.LogInfo((object)"No uncertain types are enabled, skipping uncertainty generation.");
				return uncertainWeathers;
			}
			foreach (SelectableLevel item2 in list)
			{
				int index = random.Next(list2.Count);
				string text = list2[index].CreateUncertaintyString(item2, random);
				Plugin.logger.LogDebug((object)("Rolled type: " + list2[index].Name + ", setting its uncertainty to " + text + "."));
				dictionary.Add(item2.PlanetName, text);
			}
			uncertainWeathers = dictionary;
			return dictionary;
		}
	}
	internal class Variables
	{
		public static List<SelectableLevel> GameLevels = new List<SelectableLevel>();

		public static Dictionary<string, SelectableLevel> PlanetNames = new Dictionary<string, SelectableLevel>();

		public static Dictionary<SelectableLevel, string> CurrentWeathers = new Dictionary<SelectableLevel, string>();

		internal static Dictionary<int, LevelWeatherType> GetWeatherData(string weatherData)
		{
			return JsonConvert.DeserializeObject<Dictionary<int, LevelWeatherType>>(weatherData);
		}

		internal static List<SelectableLevel> GetGameLevels()
		{
			GameLevels = SharedMethods.GetGameLevels();
			return GameLevels;
		}

		internal static List<LevelWeatherType> GetPlanetPossibleWeathers(SelectableLevel level)
		{
			return (from x in level.randomWeathers.Where((RandomWeatherWithVariables randomWeather) => (int)randomWeather.weatherType != -1 && (int)randomWeather.weatherType > 0).ToList()
				select x.weatherType).Append((LevelWeatherType)(-1)).ToList();
		}

		internal static string GetPlanetCurrentWeather(SelectableLevel level, bool uncertain = true)
		{
			if (UncertainWeather.uncertainWeathers.ContainsKey(level.PlanetName))
			{
				return UncertainWeather.uncertainWeathers[level.PlanetName];
			}
			return ((object)(LevelWeatherType)(ref level.currentWeather)).ToString();
		}

		internal static List<LevelWeatherType> GetPlanetWeightedList(SelectableLevel level, Dictionary<LevelWeatherType, int> weights, float difficulty = 0f)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Invalid comparison between Unknown and I4
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Invalid comparison between Unknown and I4
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			List<LevelWeatherType> list = new List<LevelWeatherType>();
			difficulty = Math.Clamp(difficulty, 0f, ConfigManager.MaxMultiplier.Value);
			foreach (LevelWeatherType planetPossibleWeather in GetPlanetPossibleWeathers(level))
			{
				LevelWeatherType val = planetPossibleWeather;
				int value;
				int num = (weights.TryGetValue(val, out value) ? value : 25);
				if (ConfigManager.ScaleDownClearWeather.Value && (int)val == -1)
				{
					int num2 = weights[(LevelWeatherType)(-1)];
					int num3 = weights.Sum((KeyValuePair<LevelWeatherType, int> x) => x.Value);
					int possibleWeathersWeightSum = 0;
					(from randomWeather in level.randomWeathers.ToList()
						where (int)randomWeather.weatherType > 0
						select randomWeather).ToList().ForEach(delegate(RandomWeatherWithVariables randomWeather)
					{
						//IL_0014: Unknown result type (might be due to invalid IL or missing references)
						possibleWeathersWeightSum += (weights.TryGetValue(randomWeather.weatherType, out var value3) ? value3 : 25);
					});
					double value2 = num2 * Math.Max(possibleWeathersWeightSum, 1) / num3;
					num = Convert.ToInt32(value2);
					Plugin.logger.LogDebug((object)$"Scaling down clear weather weight from {num2} to {num} : ({num2} * {Math.Max(possibleWeathersWeightSum, 1)} / {num3}) == {num}");
				}
				if (difficulty != 0f && (int)val == -1)
				{
					num = (int)((float)num * (1f - difficulty));
				}
				Plugin.logger.LogDebug((object)$"{val} has weight {num}");
				for (int i = 0; i < num; i++)
				{
					list.Add(val);
				}
			}
			return list;
		}
	}
	internal class WeatherCalculation
	{
		internal static Dictionary<string, LevelWeatherType> previousDayWeather = new Dictionary<string, LevelWeatherType>();

		internal static Dictionary<string, LevelWeatherType> NewWeathers(StartOfRound startOfRound)
		{
			//IL_066a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0340: Invalid comparison between Unknown and I4
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_0482: Unknown result type (might be due to invalid IL or missing references)
			//IL_04df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0540: Unknown result type (might be due to invalid IL or missing references)
			//IL_0509: Unknown result type (might be due to invalid IL or missing references)
			//IL_056c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0571: Unknown result type (might be due to invalid IL or missing references)
			//IL_0578: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Invalid comparison between Unknown and I4
			//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
			Plugin.logger.LogMessage((object)"SetWeathers called.");
			if (!((NetworkBehaviour)StartOfRound.Instance).IsHost)
			{
				Plugin.logger.LogMessage((object)"Not a host, cannot generate weather!");
				return null;
			}
			previousDayWeather.Clear();
			int seed = startOfRound.randomMapSeed + 31;
			Random random = new Random(seed);
			Dictionary<string, LevelWeatherType> dictionary = VanillaWeathers(0, startOfRound);
			Dictionary<string, LevelWeatherType> dictionary2 = new Dictionary<string, LevelWeatherType>();
			List<LevelWeatherType> list = new List<LevelWeatherType>(7)
			{
				(LevelWeatherType)(-1),
				(LevelWeatherType)0,
				(LevelWeatherType)1,
				(LevelWeatherType)2,
				(LevelWeatherType)3,
				(LevelWeatherType)4,
				(LevelWeatherType)5
			};
			List<SelectableLevel> gameLevels = Variables.GetGameLevels();
			int daysSpent = startOfRound.gameStats.daysSpent;
			int timesFulfilledQuota = TimeOfDay.Instance.timesFulfilledQuota;
			int num = daysSpent % 3;
			if (daysSpent == 0)
			{
				seed = ConfigManager.FirstDaySeed.Value;
				random = new Random(seed);
				List<string> noWeatherOnStartPlanets = new List<string>(2) { "41 Experimentation", "56 Vow" };
				List<SelectableLevel> list2 = gameLevels.Where((SelectableLevel level) => !noWeatherOnStartPlanets.Contains(level.PlanetName)).ToList();
				if (gameLevels.Count > 9)
				{
					int num2 = (int)((double)gameLevels.Count * 0.5);
					Plugin.logger.LogDebug((object)$"Planets without weather: {num2 + 2}");
					for (int i = 0; i < num2; i++)
					{
						string planetName = list2[random.Next(0, list2.Count)].PlanetName;
						noWeatherOnStartPlanets.Add(planetName);
						list2.RemoveAll((SelectableLevel level) => level.PlanetName == planetName);
					}
				}
				return FirstDayWeathers(gameLevels, noWeatherOnStartPlanets, random);
			}
			float num3 = (float)timesFulfilledQuota * ConfigManager.GameLengthMultiplier.Value;
			float num4 = (float)StartOfRound.Instance.livingPlayers * ConfigManager.GamePlayersMultiplier.Value;
			float num5 = num3 + num4;
			Plugin.logger.LogDebug((object)$"Difficulty multiplier: {num5}");
			foreach (SelectableLevel item in gameLevels)
			{
				previousDayWeather[item.PlanetName] = item.currentWeather;
				LevelWeatherType val = (LevelWeatherType)((!dictionary.ContainsKey(item.PlanetName)) ? (-1) : ((int)dictionary[item.PlanetName]));
				if (ConfigManager.AlwaysClear.Value)
				{
					Plugin.logger.LogDebug((object)"AlwaysClear is true, setting weather to None");
					dictionary2[item.PlanetName] = (LevelWeatherType)(-1);
					continue;
				}
				Plugin.logger.LogDebug((object)"-------------");
				Plugin.logger.LogDebug((object)(item.PlanetName ?? ""));
				Plugin.logger.LogDebug((object)$"previousDayWeather: {previousDayWeather[item.PlanetName]}");
				if ((int)previousDayWeather[item.PlanetName] == 0)
				{
					previousDayWeather[item.PlanetName] = (LevelWeatherType)(-1);
				}
				dictionary2[item.PlanetName] = (LevelWeatherType)(-1);
				List<RandomWeatherWithVariables> list3 = item.randomWeathers.Where((RandomWeatherWithVariables randomWeather) => (int)randomWeather.weatherType != -1 && (int)randomWeather.weatherType > 0).ToList();
				bool flag = item.randomWeathers.Any((RandomWeatherWithVariables randomWeather) => (int)randomWeather.weatherType == 0);
				string text = JsonConvert.SerializeObject((object)list3.Select((RandomWeatherWithVariables x) => ((object)(LevelWeatherType)(ref x.weatherType)).ToString()).ToList());
				Plugin.logger.LogDebug((object)("possibleWeathers: " + text));
				if (list3.Count == 0)
				{
					Plugin.logger.LogDebug((object)"No possible weathers, setting to None");
					dictionary2[item.PlanetName] = (LevelWeatherType)(-1);
					continue;
				}
				if (item.overrideWeather)
				{
					Plugin.logger.LogDebug((object)$"Override weather present, changing weather to {item.overrideWeatherType}");
					dictionary2[item.PlanetName] = item.overrideWeatherType;
					continue;
				}
				List<LevelWeatherType> list4 = (from x in list3.ToList()
					select x.weatherType).Append((LevelWeatherType)(-1)).ToList();
				Dictionary<LevelWeatherType, int> dictionary3 = new Dictionary<LevelWeatherType, int>();
				if (!list.Contains(previousDayWeather[item.PlanetName]))
				{
					Plugin.logger.LogDebug((object)$"Previous weather was {previousDayWeather[item.PlanetName]}, which is not vanilla - using predefined weights");
					dictionary3 = ConfigManager.Weights[(LevelWeatherType)1];
				}
				else
				{
					dictionary3 = ConfigManager.Weights[previousDayWeather[item.PlanetName]];
				}
				List<LevelWeatherType> planetWeightedList = Variables.GetPlanetWeightedList(item, dictionary3, num5);
				LevelWeatherType weather = planetWeightedList[random.Next(0, planetWeightedList.Count)];
				if ((int)weather == -1 && flag && random.Next(0, 100) < 25)
				{
					weather = (LevelWeatherType)0;
				}
				dictionary2[item.PlanetName] = weather;
				Plugin.logger.LogDebug((object)$"Selected weather: {dictionary2[item.PlanetName]}");
				try
				{
					Plugin.logger.LogDebug((object)$"Chance for that was {planetWeightedList.Where((LevelWeatherType x) => x == weather).Count()} / {planetWeightedList.Count} ({(float)planetWeightedList.Where((LevelWeatherType x) => x == weather).Count() / (float)planetWeightedList.Count * 100f}%)");
				}
				catch
				{
				}
				dictionary2[item.PlanetName] = dictionary2[item.PlanetName];
			}
			Plugin.logger.LogDebug((object)"-------------");
			return dictionary2;
		}

		private static Dictionary<string, LevelWeatherType> FirstDayWeathers(List<SelectableLevel> levels, List<string> planetsWithoutWeather, Random random)
		{
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			Plugin.logger.LogInfo((object)"First day, setting predefined weather conditions");
			ConsoleTable consoleTable = new ConsoleTable("planet", "randomWeathers");
			Dictionary<string, LevelWeatherType> dictionary = new Dictionary<string, LevelWeatherType>();
			foreach (SelectableLevel level in levels)
			{
				string planetName = level.PlanetName;
				Plugin.logger.LogDebug((object)("planet: " + planetName));
				if (ConfigManager.AlwaysClear.Value)
				{
					Plugin.logger.LogDebug((object)"AlwaysClear is true, setting weather to None");
					dictionary[level.PlanetName] = (LevelWeatherType)(-1);
					continue;
				}
				List<RandomWeatherWithVariables> list = level.randomWeathers.Where((RandomWeatherWithVariables randomWeather) => (int)randomWeather.weatherType != -1 && (int)randomWeather.weatherType > 0).ToList();
				Plugin.logger.LogDebug((object)$"randomWeathers count: {list.Count}");
				CollectionExtensions.Do<RandomWeatherWithVariables>((IEnumerable<RandomWeatherWithVariables>)list, (Action<RandomWeatherWithVariables>)delegate(RandomWeatherWithVariables x)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					Plugin.logger.LogDebug((object)$"randomWeathers: {x.weatherType}");
				});
				string text = JsonConvert.SerializeObject((object)list.Select((RandomWeatherWithVariables x) => ((object)(LevelWeatherType)(ref x.weatherType)).ToString()).ToList());
				consoleTable.AddRow(level.PlanetName, text);
				list.RemoveAll((RandomWeatherWithVariables x) => (int)x.weatherType == 5);
				if (list.Count == 0 || list == null)
				{
					Plugin.logger.LogDebug((object)("No random weathers for " + planetName + ", skipping"));
					continue;
				}
				if (planetsWithoutWeather.Contains(planetName))
				{
					dictionary[planetName] = (LevelWeatherType)(-1);
					Plugin.logger.LogDebug((object)("Skipping " + planetName + " (predefined)"));
					continue;
				}
				bool flag = random.Next(0, 100) < 5;
				RandomWeatherWithVariables val = list[random.Next(0, list.Count)];
				if (flag)
				{
					Plugin.logger.LogDebug((object)("Setting eclipsed for " + planetName));
					if (!list.Any((RandomWeatherWithVariables x) => (int)x.weatherType == 5))
					{
						Plugin.logger.LogDebug((object)("Eclipsed not possible for " + planetName + ", setting random weather"));
					}
					else
					{
						val = level.randomWeathers.First((RandomWeatherWithVariables x) => (int)x.weatherType == 5);
					}
				}
				Plugin.logger.LogDebug((object)$"Set weather for {planetName}: {val.weatherType}");
				dictionary[planetName] = list[random.Next(0, list.Count)].weatherType;
			}
			Plugin.logger.LogInfo((object)("Possible weathers:\n" + consoleTable.ToMinimalString()));
			return dictionary;
		}

		private static Dictionary<string, LevelWeatherType> VanillaWeathers(int connectedPlayersOnServer, StartOfRound startOfRound)
		{
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, LevelWeatherType> dictionary = new Dictionary<string, LevelWeatherType>();
			Random random = new Random(startOfRound.randomMapSeed + 31);
			List<SelectableLevel> list = startOfRound.levels.ToList();
			float num = 1f;
			if (connectedPlayersOnServer + 1 > 1 && startOfRound.daysPlayersSurvivedInARow > 2 && startOfRound.daysPlayersSurvivedInARow % 3 == 0)
			{
				num = (float)random.Next(15, 25) / 10f;
			}
			int num2 = Mathf.Clamp((int)((double)Mathf.Clamp(startOfRound.planetsWeatherRandomCurve.Evaluate((float)random.NextDouble()) * num, 0f, 1f) * (double)startOfRound.levels.Length), 0, startOfRound.levels.Length);
			for (int i = 0; i < num2; i++)
			{
				SelectableLevel val = list[random.Next(0, list.Count)];
				if (val.randomWeathers != null && val.randomWeathers.Length != 0)
				{
					dictionary[val.PlanetName] = val.randomWeathers[random.Next(0, val.randomWeathers.Length)].weatherType;
				}
				list.Remove(val);
			}
			return dictionary;
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "WeatherTweaks";

		public const string PLUGIN_NAME = "WeatherTweaks";

		public const string PLUGIN_VERSION = "0.5.0";
	}
}
namespace WeatherTweaks.Patches
{
	public static class LLL
	{
		internal static ManualLogSource logger = Logger.CreateLogSource("WeatherTweaks LLL");

		internal static void Init()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			Harmony val = new Harmony("WeatherTweaks.LLL");
			if (((CompatibilityBase)Plugin.LLL).IsModPresent)
			{
				logger.LogWarning((object)"Patching LethalLevelLoader");
				val.Patch((MethodBase)AccessTools.Method(typeof(TerminalManager), "GetWeatherConditions", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(LLL), "PatchNewLLL", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			else
			{
				logger.LogWarning((object)"Patching Old LethalLevelLoader");
				val.Patch((MethodBase)AccessTools.Method(typeof(TerminalManager), "GetWeatherConditions", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(LLL), "PatchOldLLL", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
		}

		private static void PatchNewLLL(ExtendedLevel extendedLevel, ref string __result)
		{
			__result = PatchLLL(extendedLevel.SelectableLevel);
		}

		private static void PatchOldLLL(SelectableLevel selectableLevel, ref string __result)
		{
			__result = PatchLLL(selectableLevel);
		}

		private static string PatchLLL(SelectableLevel selectableLevel)
		{
			string text = Variables.GetPlanetCurrentWeather(selectableLevel);
			logger.LogDebug((object)("GetMoonConditions " + selectableLevel.PlanetName + "::" + text));
			if (text == "None")
			{
				text = "";
			}
			else if (!text.Contains("[") && !text.Contains("]"))
			{
				text = "(" + text + ")";
			}
			return text;
		}
	}
	internal class Malfunctions
	{
		private static Type StartOfRoundPatches;

		private static Assembly assembly;

		private static Harmony harmony;

		internal static void Init()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			assembly = ((object)Chainloader.PluginInfos["com.zealsprince.malfunctions"].Instance).GetType().Assembly;
			StartOfRoundPatches = AccessTools.TypeByName("Malfunctions.Patches.StartOfRoundPatches");
			if (StartOfRoundPatches == null)
			{
				Plugin.logger.LogError((object)"Could not find StartOfRoundPatches class in Malfunctions assembly");
			}
			else
			{
				Plugin.logger.LogDebug((object)"Found StartOfRoundPatches class in Malfunctions assembly");
			}
			harmony = new Harmony("WeatherTweaks.Malfunctions");
			HarmonyMethod val = new HarmonyMethod(typeof(Malfunctions).GetMethod("EclipseOnEnablePatch"));
			harmony.Patch((MethodBase)AccessTools.Method(StartOfRoundPatches, "OverwriteMapScreenInfo", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, val, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static IEnumerable<CodeInstruction> EclipseOnEnablePatch(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected O, but got Unknown
			ManualLogSource logger = Plugin.logger;
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldsfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Brtrue, (object)null, (string)null)
			});
			val.Repeat((Action<CodeMatcher>)delegate(CodeMatcher match)
			{
				match.RemoveInstructions(3);
			}, (Action<string>)null);
			return val.InstructionEnumeration();
		}
	}
	public class OpenMonitorsPatch
	{
		private static string guid = "xxxstoner420bongmasterxxx.open_monitors";

		public static void Init()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			Plugin.logger.LogDebug((object)"OpenMonitorsPatch Init");
			Harmony val = new Harmony("WeatherTweaks.OpenMonitors");
			val.Unpatch((MethodBase)typeof(StartOfRound).GetMethod("SetMapScreenInfoToCurrentLevel", BindingFlags.Instance | BindingFlags.Public), (HarmonyPatchType)0, guid);
			Plugin.logger.LogWarning((object)"Unpatched StartOfRound.SetMapScreenInfoToCurrentLevel");
			val.Unpatch((MethodBase)typeof(Terminal).GetMethod("TextPostProcess", BindingFlags.Instance | BindingFlags.NonPublic), (HarmonyPatchType)0, guid);
			Plugin.logger.LogWarning((object)"Unpatched Terminal.TextPostProcess");
		}
	}
}
namespace WeatherTweaks.Modules
{
	internal class Types
	{
		public abstract class UncertainWeatherType
		{
			public string Name;

			public ConfigEntry<bool> Enabled;

			public abstract string CreateUncertaintyString(SelectableLevel level, Random random);

			public UncertainWeatherType(string name)
			{
				Name = name;
				Plugin.logger.LogDebug((object)("Creating UncertainWeatherType: " + Name));
				Enabled = ConfigManager.Instance.configFile.Bind<bool>("1a> Uncertain mechanics", Name + " Enabled", true, "Enable " + Name + " uncertainty");
			}
		}
	}
}