using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using BrutalCompanyMinus.Minus;
using CodeRebirth;
using CodeRebirth.src;
using CodeRebirth.src.MiscScripts;
using ConsoleTables;
using Dawn;
using GameNetcodeStuff;
using HarmonyLib;
using Imperium.API.Types.Networking;
using JLL.Components;
using LethalLib.Modules;
using Malfunctions;
using Microsoft.CodeAnalysis;
using MonoMod.RuntimeDetour;
using MonoMod.Utils;
using MrovLib;
using MrovLib.Compatibility;
using MrovLib.Definitions;
using MrovLib.Events;
using Newtonsoft.Json;
using On;
using TMPro;
using Unity.Collections;
using Unity.Netcode;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.InputSystem.Utilities;
using UnityEngine.Serialization;
using WeatherRegistry.Algorithms;
using WeatherRegistry.Compatibility;
using WeatherRegistry.Definitions;
using WeatherRegistry.Editor;
using WeatherRegistry.Enums;
using WeatherRegistry.Managers;
using WeatherRegistry.Modules;
using WeatherRegistry.NetcodePatcher;
using WeatherRegistry.Networking;
using WeatherRegistry.Patches;
using WeatherRegistry.Utils;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("AmazingAssets.TerrainToMesh")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp-firstpass")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: IgnoresAccessChecksTo("BrutalCompanyMinus")]
[assembly: IgnoresAccessChecksTo("ClientNetworkTransform")]
[assembly: IgnoresAccessChecksTo("CodeRebirth")]
[assembly: IgnoresAccessChecksTo("com.olegknyazev.softmask")]
[assembly: IgnoresAccessChecksTo("DissonanceVoip")]
[assembly: IgnoresAccessChecksTo("DunGen")]
[assembly: IgnoresAccessChecksTo("DunGen.Integration.ASPP")]
[assembly: IgnoresAccessChecksTo("DunGen.Integration.UnityNav")]
[assembly: IgnoresAccessChecksTo("EasyTextEffects")]
[assembly: IgnoresAccessChecksTo("Facepunch Transport for Netcode for GameObjects")]
[assembly: IgnoresAccessChecksTo("Facepunch.Steamworks.Win64")]
[assembly: IgnoresAccessChecksTo("Malfunctions")]
[assembly: IgnoresAccessChecksTo("MrovLib")]
[assembly: IgnoresAccessChecksTo("Unity.AI.Navigation")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging")]
[assembly: IgnoresAccessChecksTo("Unity.Animation.Rigging.DocCodeExamples")]
[assembly: IgnoresAccessChecksTo("Unity.Burst")]
[assembly: IgnoresAccessChecksTo("Unity.Burst.Unsafe")]
[assembly: IgnoresAccessChecksTo("Unity.Collections")]
[assembly: IgnoresAccessChecksTo("Unity.Collections.LowLevel.ILSupport")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem")]
[assembly: IgnoresAccessChecksTo("Unity.InputSystem.ForUI")]
[assembly: IgnoresAccessChecksTo("Unity.Jobs")]
[assembly: IgnoresAccessChecksTo("Unity.Mathematics")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.Common")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.MetricTypes")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStats")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Component")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsMonitor.Implementation")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetStatsReporting")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkProfiler.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Multiplayer.Tools.NetworkSolutionInterface")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Netcode.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.Networking.Transport")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Csg")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.KdTree")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Poly2Tri")]
[assembly: IgnoresAccessChecksTo("Unity.ProBuilder.Stl")]
[assembly: IgnoresAccessChecksTo("Unity.Profiling.Core")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.Core.ShaderLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Config.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.HighDefinition.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.RenderPipelines.ShaderGraph.ShaderGraphLibrary")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Authentication")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Analytics")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Components")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Configuration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Device")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Environments.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Internal")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Networking")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Registration")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Scheduler")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Telemetry")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Core.Threading")]
[assembly: IgnoresAccessChecksTo("Unity.Services.QoS")]
[assembly: IgnoresAccessChecksTo("Unity.Services.Relay")]
[assembly: IgnoresAccessChecksTo("Unity.TextMeshPro")]
[assembly: IgnoresAccessChecksTo("Unity.Timeline")]
[assembly: IgnoresAccessChecksTo("Unity.VisualEffectGraph.Runtime")]
[assembly: IgnoresAccessChecksTo("Unity.XR.CoreUtils")]
[assembly: IgnoresAccessChecksTo("Unity.XR.Management")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.ConformanceAutomation")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.MetaQuestSupport")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.MockRuntime")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.OculusQuestSupport")]
[assembly: IgnoresAccessChecksTo("Unity.XR.OpenXR.Features.RuntimeDebugger")]
[assembly: IgnoresAccessChecksTo("UnityEngine.ARModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.NVIDIAModule")]
[assembly: IgnoresAccessChecksTo("UnityEngine.SpatialTracking")]
[assembly: IgnoresAccessChecksTo("UnityEngine.UI")]
[assembly: IgnoresAccessChecksTo("UnityEngine.XR.LegacyInputHelpers")]
[assembly: AssemblyCompany("WeatherRegistry")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("A Weather API for Lethal Company.")]
[assembly: AssemblyFileVersion("0.8.8.0")]
[assembly: AssemblyInformationalVersion("0.8.8+a83bedb581ec6d50800926c19f47541431b45c96")]
[assembly: AssemblyProduct("WeatherRegistry")]
[assembly: AssemblyTitle("WeatherRegistry")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/AndreyMrovol/LethalWeatherRegistry/")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[module: NetcodePatchedAssembly]
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 WeatherRegistry
{
public class Rarity
{
private int _weight;
public int Weight
{
get
{
return _weight;
}
set
{
_weight = Math.Clamp(value, 0, 10000);
}
}
}
public class NameRarity : Rarity
{
public string Name { get; set; }
}
public class LevelRarity : Rarity
{
public SelectableLevel Level { get; set; }
}
public class WeatherRarity : Rarity
{
public Weather Weather { get; set; }
}
public abstract class ConfigHandler<T, CT> : WeatherRegistry.Utils.ConfigHandler<T, CT>
{
public ConfigFile ConfigFile { get; set; } = ConfigManager.configFile;
public ConfigHandler(CT value, bool enabled = true)
{
((ConfigHandler<T, CT>)this).DefaultValue = value;
base.Enabled = enabled;
}
public void SetConfigEntry(Weather weather, string configTitle, ConfigDescription configDescription = null)
{
if (base.Enabled)
{
((ConfigHandler<T, CT>)this).ConfigEntry = ConfigFile.Bind<CT>(ConfigHelper.CleanStringForConfig(weather.ConfigCategory), ConfigHelper.CleanStringForConfig(configTitle), ((ConfigHandler<T, CT>)this).DefaultValue, configDescription);
return;
}
((ConfigHandler<T, CT>)this).ConfigEntry = null;
((Logger)Plugin.debugLogger).LogDebug("Config entry for " + weather.Name + ": " + configTitle + " is disabled");
}
public void SetConfigEntry(string configCategory, string configTitle, ConfigDescription configDescription = null)
{
if (base.Enabled)
{
((ConfigHandler<T, CT>)this).ConfigEntry = ConfigFile.Bind<CT>(ConfigHelper.CleanStringForConfig(configCategory), ConfigHelper.CleanStringForConfig(configTitle), ((ConfigHandler<T, CT>)this).DefaultValue, configDescription);
return;
}
((ConfigHandler<T, CT>)this).ConfigEntry = null;
((Logger)Plugin.debugLogger).LogDebug("Config entry " + configTitle + " is disabled");
}
}
public class LevelListConfigHandler : ConfigHandler<SelectableLevel[], string>
{
public override SelectableLevel[] Value => ConfigHelper.ConvertStringToLevels(base.ConfigEntryActive ? ((ConfigHandler<SelectableLevel[], string>)this).ConfigEntry.Value : ((ConfigHandler<SelectableLevel[], string>)this).DefaultValue);
public LevelListConfigHandler(string value, bool enabled = true)
: base(value, enabled)
{
}
public LevelListConfigHandler(string[] value, bool enabled = true)
: base(string.Join(";", value), enabled)
{
}
}
public class LevelWeightsConfigHandler : ConfigHandler<LevelRarity[], string>
{
public override LevelRarity[] Value => ConfigHelper.ConvertStringToLevelRarities(base.ConfigEntryActive ? ((ConfigHandler<LevelRarity[], string>)this).ConfigEntry.Value : ((ConfigHandler<LevelRarity[], string>)this).DefaultValue);
public LevelWeightsConfigHandler(string value, bool enabled = true)
: base(value, enabled)
{
}
public LevelWeightsConfigHandler(string[] value, bool enabled = true)
: base(string.Join(";", value), enabled)
{
}
}
public class WeatherWeightsConfigHandler : ConfigHandler<WeatherRarity[], string>
{
public override WeatherRarity[] Value => ConfigHelper.ConvertStringToWeatherWeights(base.ConfigEntryActive ? ((ConfigHandler<WeatherRarity[], string>)this).ConfigEntry.Value : ((ConfigHandler<WeatherRarity[], string>)this).DefaultValue);
public WeatherWeightsConfigHandler(string value, bool enabled = true)
: base(value, enabled)
{
}
public WeatherWeightsConfigHandler(string[] value, bool enabled = true)
: base(string.Join(";", value), enabled)
{
}
}
public class BooleanConfigHandler : ConfigHandler<bool, bool>
{
public override bool Value
{
get
{
if (!base.ConfigEntryActive)
{
return ((ConfigHandler<bool, bool>)this).DefaultValue;
}
return ((ConfigHandler<bool, bool>)this).ConfigEntry.Value;
}
}
public BooleanConfigHandler(bool value, bool enabled = true)
: base(value, enabled)
{
}
public BooleanConfigHandler(FilteringOption filteringOption, bool enabled = true)
: base(filteringOption == FilteringOption.Include, enabled)
{
}
}
public class IntegerConfigHandler : ConfigHandler<int, int>
{
public override int Value
{
get
{
if (!base.ConfigEntryActive)
{
return ((ConfigHandler<int, int>)this).DefaultValue;
}
return ((ConfigHandler<int, int>)this).ConfigEntry.Value;
}
}
public IntegerConfigHandler(int value, bool enabled = true)
: base(value, enabled)
{
}
}
public class FloatConfigHandler : ConfigHandler<float, float>
{
public override float Value
{
get
{
if (!base.ConfigEntryActive)
{
return ((ConfigHandler<float, float>)this).DefaultValue;
}
return ((ConfigHandler<float, float>)this).ConfigEntry.Value;
}
}
public FloatConfigHandler(float value, bool enabled = true)
: base(value, enabled)
{
}
}
public class StringConfigHandler : ConfigHandler<string, string>
{
public override string Value
{
get
{
if (!base.ConfigEntryActive)
{
return ((ConfigHandler<string, string>)this).DefaultValue;
}
return ((ConfigHandler<string, string>)this).ConfigEntry.Value;
}
}
public StringConfigHandler(string value, bool enabled = true)
: base(value, enabled)
{
}
}
public class ConfigHelper
{
private static Logger logger = new Logger("ConfigHelper", (LoggingType)1);
private static readonly Regex ConfigCleanerRegex = new Regex("[\\n\\t\"`\\[\\]']");
private static Dictionary<string, Weather> _weathersDictionary = null;
public static Dictionary<string, Weather> StringToWeather
{
get
{
if (_weathersDictionary != null)
{
return _weathersDictionary;
}
Dictionary<string, Weather> Weathers = new Dictionary<string, Weather>();
WeatherManager.Weathers.ToList().ForEach(delegate(Weather weather)
{
Weathers.TryAdd(weather.Name.ToLowerInvariant(), weather);
Weathers.TryAdd(GetAlphanumericName(weather).ToLowerInvariant(), weather);
});
_weathersDictionary = Weathers;
return Weathers;
}
set
{
_weathersDictionary = value;
}
}
internal static string CleanStringForConfig(string input)
{
return ConfigCleanerRegex.Replace(input, string.Empty).Trim();
}
public static Weather ResolveStringToWeather(string str)
{
return StringToWeather.GetValueOrDefault(str.ToLowerInvariant());
}
public static List<Weather> ResolveStringToWeathers(string str)
{
if (string.IsNullOrWhiteSpace(str))
{
return new List<Weather>();
}
string[] array = ConvertStringToArray(str);
List<Weather> list = new List<Weather>();
string[] array2 = array;
foreach (string text in array2)
{
Weather weather = ResolveStringToWeather(text);
if (weather != null)
{
list.Add(weather);
}
else
{
((Logger)logger).LogWarning("Invalid weather name: " + text);
}
}
return list;
}
public static string GetNumberlessName(SelectableLevel level)
{
return StringResolver.GetNumberlessName(level);
}
public static string GetAlphanumericName(SelectableLevel level)
{
Regex regex = new Regex("^[0-9]+|[-_/\\\\\\ ]");
return new string(regex.Replace(level.PlanetName, "").AsSpan());
}
public static string GetAlphanumericName(Weather weather)
{
Regex regex = new Regex("^[0-9]+|[-_/\\\\\\ ]");
return new string(regex.Replace(weather.Name, "").AsSpan());
}
public static string GetAlphanumericName(string str)
{
Regex regex = new Regex("^[0-9]+|[-_/\\\\\\ ]");
return new string(regex.Replace(str, "").AsSpan());
}
public static string[] ConvertStringToArray(string str)
{
return (from s in str.Split(';')
where !string.IsNullOrWhiteSpace(s)
select s.Trim()).ToArray();
}
public static SelectableLevel[] ConvertStringToLevels(string str)
{
return StringResolver.ResolveStringToLevels(str);
}
public static NameRarity[] ConvertStringToRarities(string str)
{
string[] array = ConvertStringToArray(str);
Dictionary<string, int> dictionary = new Dictionary<string, int>();
string[] array2 = array;
foreach (string text in array2)
{
string[] array3 = text.Split('@');
if (array3.Length == 2 && int.TryParse(array3[1], out var result))
{
string key = array3[0].Trim();
if (!dictionary.ContainsKey(key))
{
dictionary.Add(key, result);
}
}
}
return dictionary.Select((KeyValuePair<string, int> rarity) => new NameRarity
{
Name = rarity.Key,
Weight = rarity.Value
}).ToArray();
}
public static LevelRarity[] ConvertStringToLevelRarities(string str)
{
Dictionary<SelectableLevel, int> dictionary = new Dictionary<SelectableLevel, int>();
NameRarity[] array = ConvertStringToRarities(str);
NameRarity[] array2 = array;
foreach (NameRarity nameRarity in array2)
{
SelectableLevel[] array3 = StringResolver.ResolveStringToLevels(nameRarity.Name);
SelectableLevel[] array4 = array3;
foreach (SelectableLevel val in array4)
{
if (!((Object)(object)val == (Object)null))
{
dictionary.TryAdd(val, nameRarity.Weight);
}
}
}
return dictionary.Select((KeyValuePair<SelectableLevel, int> rarity) => new LevelRarity
{
Level = rarity.Key,
Weight = rarity.Value
}).ToArray();
}
public static WeatherRarity[] ConvertStringToWeatherWeights(string str)
{
Dictionary<Weather, int> dictionary = new Dictionary<Weather, int>();
NameRarity[] array = ConvertStringToRarities(str);
NameRarity[] array2 = array;
foreach (NameRarity nameRarity in array2)
{
Weather weather = ResolveStringToWeather(nameRarity.Name);
if (weather != null)
{
dictionary.TryAdd(weather, nameRarity.Weight);
}
}
return dictionary.Select((KeyValuePair<Weather, int> rarity) => new WeatherRarity
{
Weather = rarity.Key,
Weight = rarity.Value
}).ToArray();
}
}
internal class ConfigManager
{
internal static ConfigFile configFile;
internal static ConfigManager Instance { get; private set; }
internal static ConfigEntry<string> BundleBlacklist { get; private set; }
internal static List<string> BlacklistedBundles => (from s in BundleBlacklist.Value.Split(';')
select s.Trim() into s
where !string.IsNullOrEmpty(s)
select s).ToList();
internal static ConfigEntry<LoggingType> LoggingLevels { get; private set; }
internal static ConfigEntry<WeatherAlgorithm> WeatherAlgorithm { get; private set; }
internal static ConfigEntry<bool> FirstDayClear { get; private set; }
internal static ConfigEntry<bool> ColoredWeathers { get; private set; }
internal static ConfigEntry<bool> PlanetVideos { get; private set; }
internal static ConfigEntry<bool> ShowWeatherMultipliers { get; private set; }
internal static ConfigEntry<bool> ShowClearWeather { get; private set; }
internal static ConfigEntry<bool> UseScrapMultipliers { get; private set; }
internal static ConfigEntry<bool> EnableMeltdownPatch { get; private set; }
internal static void Init(ConfigFile config)
{
Instance = new ConfigManager(config);
}
private ConfigManager(ConfigFile config)
{
configFile = config;
BundleBlacklist = configFile.Bind<string>("|General", "Bundle Blacklist", "", "Semicolon-separated list of asset bundle names that shouldn't be loaded.");
LoggingLevels = configFile.Bind<LoggingType>("|Logging", "Display Log Levels", (LoggingType)0, "Select which logs to show.");
WeatherAlgorithm = configFile.Bind<WeatherAlgorithm>("|WeatherSelection", "Weather Selection Algorithm", WeatherRegistry.Enums.WeatherAlgorithm.Registry, "Select the algorithm to use during weather selection.");
FirstDayClear = configFile.Bind<bool>("|WeatherSelection", "First Day Clear Weather", false, "If enabled, the first day will always have clear weather, on all planets, regardless of the selected algorithm.");
ColoredWeathers = configFile.Bind<bool>("|General", "Colored Weathers", true, "Enable colored weathers on map screen");
PlanetVideos = configFile.Bind<bool>("|General", "Planet Videos", true, "Display planet videos on map screen");
ShowWeatherMultipliers = configFile.Bind<bool>("|General", "Show Weather Multipliers", false, "Show weather multipliers on map screen");
ShowClearWeather = configFile.Bind<bool>("|General", "Show Clear Weather", true, "Display 'WEATHER: CLEAR' on map screen when weather is clear");
UseScrapMultipliers = configFile.Bind<bool>("|General", "Scrap multipliers", true, "Use Registry's scrap multipliers. Disable if you prefer to use other mod's multiplier settings.");
EnableMeltdownPatch = configFile.Bind<bool>("|Patches", "Enable Facility Meltdown Compatibility Patch", true, "Allows you to disable FacilityMeltdown patch (for when the mod is not working correctly)");
}
internal void RemoveOrphanedEntries()
{
Plugin.logger.LogInfo((object)"Removing orphaned config entries...");
PropertyInfo property = ((object)configFile).GetType().GetProperty("OrphanedEntries", BindingFlags.Instance | BindingFlags.NonPublic);
Dictionary<ConfigDefinition, string> orphanedEntries = (Dictionary<ConfigDefinition, string>)property.GetValue(configFile, null);
List<KeyValuePair<ConfigDefinition, string>> list = orphanedEntries.Where((KeyValuePair<ConfigDefinition, string> entry) => entry.Key.Section.Contains("|")).ToList();
if (list.Count != 0)
{
Plugin.logger.LogWarning((object)$"Found {list.Count} orphaned config entries, removing...");
list.ForEach(delegate(KeyValuePair<ConfigDefinition, string> entry)
{
((Logger)Plugin.debugLogger).LogWarning("Removing orphaned config entry: " + entry.Key.Section + " - " + entry.Key.Key);
orphanedEntries.Remove(entry.Key);
});
configFile.Save();
}
}
internal static void ReloadConfigfile()
{
Plugin.logger.LogInfo((object)"Reloading config file...");
configFile.Reload();
}
internal static void SettingChanged(object sender, SettingChangedEventArgs args)
{
ConfigEntryBase changedSetting = args.ChangedSetting;
((Logger)Plugin.debugLogger).LogInfo($"Setting changed: {changedSetting.Definition.Section}/{changedSetting.Definition.Key} changed to {changedSetting.BoxedValue}");
}
}
internal class Defaults
{
internal static List<LevelWeatherType> VanillaWeathers = Defaults.VanillaWeathers;
internal static Dictionary<LevelWeatherType, Color> VanillaWeatherColors = new Dictionary<LevelWeatherType, Color>
{
{
(LevelWeatherType)(-1),
new Color(0.41f, 1f, 0.42f, 1f)
},
{
(LevelWeatherType)0,
new Color(0.62f, 0.4f, 0.42f, 1f)
},
{
(LevelWeatherType)3,
new Color(1f, 0.86f, 0f, 1f)
},
{
(LevelWeatherType)1,
new Color(1f, 0.86f, 0f, 1f)
},
{
(LevelWeatherType)2,
new Color(1f, 0.57f, 0f, 1f)
},
{
(LevelWeatherType)4,
new Color(1f, 0.57f, 0f, 1f)
},
{
(LevelWeatherType)5,
new Color(1f, 0f, 0f, 1f)
}
};
internal static Dictionary<LevelWeatherType, string> VanillaWeatherToWeatherWeights = new Dictionary<LevelWeatherType, string>
{
{
(LevelWeatherType)(-1),
"None@160; Rainy@100; Stormy@70; Flooded@20; Foggy@40; Eclipsed@10"
},
{
(LevelWeatherType)1,
"None@100; Rainy@60; Stormy@40; Flooded@30; Foggy@50; Eclipsed@20"
},
{
(LevelWeatherType)2,
"None@160; Rainy@110; Stormy@10; Flooded@120; Foggy@20; Eclipsed@80"
},
{
(LevelWeatherType)4,
"None@160; Rainy@60; Stormy@50; Flooded@10; Foggy@60; Eclipsed@40"
},
{
(LevelWeatherType)3,
"None@200; Rainy@60; Stormy@50; Flooded@10; Foggy@30; Eclipsed@20"
},
{
(LevelWeatherType)5,
"None@300; Rainy@40; Stormy@16; Flooded@20; Foggy@60; Eclipsed@10"
}
};
public static readonly string DefaultLevelFilters = "Company";
public static readonly string DefaultLevelWeights = "MoonName@50";
public static readonly string DefaultWeatherToWeatherWeights = "WeatherName@50";
public static readonly int DefaultWeight = 100;
public static readonly float ScrapAmountMultiplier = 1f;
public static readonly float ScrapValueMultiplier = 1f;
public static readonly FilteringOption FilteringOption = FilteringOption.Exclude;
internal static Color LethalLibColor = new Color(0f, 0.44f, 0.76f, 1f);
internal static readonly string WeatherSaveKey = "WeatherRegistryCurrentWeathers";
internal static readonly Dictionary<string, string> SpecialSymbolMap = new Dictionary<string, string>
{
{ "+", "plus" },
{ "/", "slash" },
{ ">", "arrow" },
{ "?", "question" }
};
}
public class EventManager
{
public static WeatherRegistryEvent DisableAllWeathers = new WeatherRegistryEvent();
public static WeatherRegistryEvent BeforeSetupStart = new WeatherRegistryEvent();
public static WeatherRegistryEvent SetupFinished = new WeatherRegistryEvent();
public static WeatherRegistryEvent<int> DayChanged = new WeatherRegistryEvent<int>();
public static WeatherRegistryEvent<(SelectableLevel level, Weather weather, string screenText)> MapScreenUpdated = new WeatherRegistryEvent<(SelectableLevel, Weather, string)>();
public static WeatherRegistryEvent<(SelectableLevel level, Weather weather)> WeatherChanged = new WeatherRegistryEvent<(SelectableLevel, Weather)>();
public static WeatherRegistryEvent<(SelectableLevel level, Weather weather)> ShipLanding = new WeatherRegistryEvent<(SelectableLevel, Weather)>();
}
[CreateAssetMenu(fileName = "WeatherEffect", menuName = "WeatherRegistry/ImprovedWeatherEffect", order = 90)]
public class ImprovedWeatherEffect : ScriptableObject
{
[JsonIgnore]
[Tooltip("The GameObject that is visible only for the player, i.e. rain particles, sound effects etc.")]
[SerializeField]
public GameObject EffectObject;
[JsonIgnore]
[Tooltip("The GameObject that is placed in the world, i.e. floodwater, lightning bolts etc.")]
[SerializeField]
public GameObject WorldObject;
private bool _effectEnabled;
[Tooltip("The name of sun animator's bool that gets toggled when the weather effect is enabled. Vanilla uses '' for clear weather, 'overcast' for stormy/flooded, 'eclipse' for eclipsed.")]
[field: SerializeField]
public string SunAnimatorBool { get; set; }
[field: SerializeField]
public int DefaultVariable1 { get; set; }
[field: SerializeField]
public int DefaultVariable2 { get; set; }
public LevelWeatherType LevelWeatherType { get; internal set; }
public WeatherEffect VanillaWeatherEffect { get; internal set; }
public virtual bool EffectEnabled
{
get
{
return _effectEnabled;
}
set
{
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)this == (Object)null || !Object.op_Implicit((Object)(object)this))
{
((Logger)WeatherEffectManager.Logger).LogDebug("Attempted to set EffectEnabled on a destroyed ImprovedWeatherEffect, skipping!");
return;
}
((Logger)WeatherEffectManager.Logger).LogDebug($"Setting effect {((Object)this).name} to {value} - is player inside? {Settings.IsPlayerInside}");
if (!Settings.IsPlayerInside)
{
GameObject effectObject = EffectObject;
if (effectObject != null)
{
effectObject.SetActive(value);
}
WeatherEffectController.SetTimeOfDayEffect(LevelWeatherType, value);
}
GameObject worldObject = WorldObject;
if (worldObject != null)
{
worldObject.SetActive(value);
}
_effectEnabled = value;
}
}
public bool EffectActive
{
get
{
GameObject effectObject = EffectObject;
if (effectObject == null)
{
return false;
}
return effectObject.activeSelf;
}
}
public virtual void DisableEffect(bool permament = false)
{
if (permament)
{
EffectEnabled = false;
return;
}
GameObject effectObject = EffectObject;
if (effectObject != null)
{
effectObject.SetActive(false);
}
}
public ImprovedWeatherEffect(GameObject effectObject, GameObject worldObject)
{
EffectObject = effectObject;
WorldObject = worldObject;
GameObject effectObject2 = EffectObject;
if (effectObject2 != null)
{
effectObject2.SetActive(false);
}
GameObject worldObject2 = WorldObject;
if (worldObject2 != null)
{
worldObject2.SetActive(false);
}
}
public ImprovedWeatherEffect(WeatherEffect weatherEffect)
{
EffectObject = weatherEffect.effectObject;
WorldObject = weatherEffect.effectPermanentObject;
VanillaWeatherEffect = weatherEffect;
GameObject effectObject = EffectObject;
if (effectObject != null)
{
effectObject.SetActive(false);
}
GameObject worldObject = WorldObject;
if (worldObject != null)
{
worldObject.SetActive(false);
}
}
}
public class Logger : Logger
{
public override ManualLogSource LogSource { get; set; }
public Logger(string SourceName, LoggingType defaultLoggingType = 1)
: base(SourceName, defaultLoggingType)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
((Logger)this).ModName = SourceName;
((Logger)this).LogSource = Logger.CreateLogSource("WeatherRegistry");
((Logger)this)._name = SourceName;
}
public override bool ShouldLog(LoggingType type)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
return ConfigManager.LoggingLevels.Value >= type;
}
}
[BepInPlugin("mrov.WeatherRegistry", "WeatherRegistry", "0.8.8")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInIncompatibility("Ozzymops.DisableStormyWeather")]
public class Plugin : BaseUnityPlugin
{
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static EventHandler<SettingChangedEventArgs> <>9__15_3;
public static ParameterEvent<string> <>9__15_1;
public static EventHandler<SettingChangedEventArgs> <>9__15_4;
public static Event <>9__15_2;
internal void <Awake>b__15_1(string scene)
{
if (scene == "MainMenu")
{
ConfigManager.configFile.SettingChanged -= delegate(object sender, SettingChangedEventArgs args)
{
ConfigManager.SettingChanged(sender, args);
};
}
}
internal void <Awake>b__15_3(object sender, SettingChangedEventArgs args)
{
ConfigManager.SettingChanged(sender, args);
}
internal void <Awake>b__15_2()
{
TerminalNodeManager.Init();
ConfigManager.configFile.SettingChanged += delegate(object sender, SettingChangedEventArgs args)
{
ConfigManager.SettingChanged(sender, args);
};
}
internal void <Awake>b__15_4(object sender, SettingChangedEventArgs args)
{
ConfigManager.SettingChanged(sender, args);
}
}
[Obsolete("Use PluginInfo.PLUGIN_GUID instead")]
public const string GUID = "mrov.WeatherRegistry";
internal static ManualLogSource logger;
internal static Logger debugLogger = new Logger("Debug", (LoggingType)1);
internal static Harmony harmony = new Harmony("mrov.WeatherRegistry");
internal static AssetBundleManager AssetBundleManager;
internal static bool IsLethalLibLoaded = false;
internal static JLLCompat JLLCompat;
internal static LobbyControlCompat LobbyControlCompat;
internal static FacilityMeltdownCompat FacilityMeltdownCompat;
internal static ImperiumCompat ImperiumCompat;
internal static MalfunctionsCompat MalfunctionsCompat;
internal static CRCompat CRCompat;
internal static ButteryFixesCompat ButteryFixesCompat;
internal static BrutalCompanyCompat BrutalCompanyCompat;
internal static Hook WeatherTypeEnumHook;
private void Awake()
{
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0064: Expected O, but got Unknown
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Expected O, but got Unknown
//IL_0110: Unknown result type (might be due to invalid IL or missing references)
//IL_011a: Expected O, but got Unknown
logger = ((BaseUnityPlugin)this).Logger;
harmony.PatchAll();
WeatherRegistry.Patches.NetcodePatcher.PatchNetcodeMethods();
ConfigManager.Init(((BaseUnityPlugin)this).Config);
AssetBundleManager assetBundleManager = new AssetBundleManager();
((AssetBundleLoaderManager)assetBundleManager).BundleBlacklist = ConfigManager.BlacklistedBundles;
AssetBundleManager = assetBundleManager;
((AssetBundleLoaderManager)AssetBundleManager).LoadAllBundles();
((AssetBundleLoaderManager)AssetBundleManager).ConvertLoadedAssets();
EventManager.MainMenuLoaded.AddListener((Event)delegate
{
MainMenuInit();
ConfigManager.Instance.RemoveOrphanedEntries();
});
EventManager.SceneLoaded.AddListener((ParameterEvent<string>)delegate(string scene)
{
if (scene == "MainMenu")
{
ConfigManager.configFile.SettingChanged -= delegate(object sender, SettingChangedEventArgs args)
{
ConfigManager.SettingChanged(sender, args);
};
}
});
WeatherRegistryEvent setupFinished = EventManager.SetupFinished;
object obj = <>c.<>9__15_2;
if (obj == null)
{
Event val = delegate
{
TerminalNodeManager.Init();
ConfigManager.configFile.SettingChanged += delegate(object sender, SettingChangedEventArgs args)
{
ConfigManager.SettingChanged(sender, args);
};
};
<>c.<>9__15_2 = val;
obj = (object)val;
}
((CustomEvent)setupFinished).AddListener((Event)obj);
if (Chainloader.PluginInfos.ContainsKey("evaisa.lethallib"))
{
IsLethalLibLoaded = true;
LethalLibPatch.Init();
}
else
{
logger.LogDebug((object)"LethalLib not detected!");
}
WeatherTypeEnumHook = new Hook((MethodBase)typeof(Enum).GetMethod("ToString", Array.Empty<Type>()), typeof(EnumPatches).GetMethod("LevelWeatherTypeEnumToStringHook"));
JLLCompat = new JLLCompat("JacobG5.JLL");
LobbyControlCompat = new LobbyControlCompat("mattymatty.LobbyControl");
LobbyControlCompat.Init();
FacilityMeltdownCompat = new FacilityMeltdownCompat("me.loaforc.facilitymeltdown");
ImperiumCompat = new ImperiumCompat("giosuel.Imperium");
MalfunctionsCompat = new MalfunctionsCompat("com.zealsprince.malfunctions");
CRCompat = new CRCompat("CodeRebirth", "1.4.1");
ButteryFixesCompat = new ButteryFixesCompat("butterystancakes.lethalcompany.butteryfixes");
BrutalCompanyCompat = new BrutalCompanyCompat("SoftDiamond.BrutalCompanyMinusExtraReborn");
((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin mrov.WeatherRegistry is loaded!");
}
private void MainMenuInit()
{
ImperiumCompat.Init();
CRCompat.Init();
ButteryFixesCompat.Init();
BrutalCompanyCompat.Init();
}
}
public class Settings
{
public static Dictionary<string, TMP_ColorGradient> ScreenMapColors = new Dictionary<string, TMP_ColorGradient>();
public static bool SetupFinished => WeatherManager.IsSetupFinished;
public static WeatherSelectionAlgorithm WeatherSelectionAlgorithm => WeatherCalculation.WeatherSelectionAlgorithm;
public static bool IsGameStarted { get; internal set; } = false;
public static bool IsPlayerInside { get; set; } = false;
public static bool SelectWeathers { get; set; } = true;
public static bool ScrapMultipliers { get; set; } = ConfigManager.UseScrapMultipliers.Value;
public static bool ColoredWeathers { get; set; } = ConfigManager.ColoredWeathers.Value;
public static bool WeatherOverrideNames { get; set; } = true;
public static bool PlanetVideos { get; set; } = ConfigManager.PlanetVideos.Value;
public static bool MapScreenOverride { get; set; } = true;
}
public static class WeatherController
{
private static Logger Logger = new Logger("WeatherController", (LoggingType)0);
public static void ChangeCurrentWeather(Weather weather)
{
SelectableLevel currentLevel = StartOfRound.Instance.currentLevel;
ChangeWeather(currentLevel, weather);
}
public static void ChangeCurrentWeather(LevelWeatherType weatherType)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
SelectableLevel currentLevel = StartOfRound.Instance.currentLevel;
ChangeWeather(currentLevel, weatherType);
}
public static void ChangeWeather(SelectableLevel level, LevelWeatherType weatherType)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
Weather weather = WeatherManager.GetWeather(weatherType);
ChangeWeather(level, weather);
}
public static void ChangeWeather(SelectableLevel level, Weather weather)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: 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)
//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)
if (!Settings.SelectWeathers)
{
return;
}
if (weather == null)
{
((Logger)Logger).LogWarning("Weather is null, cannot change weather");
return;
}
level.currentWeather = weather.VanillaWeatherType;
if ((Object)(object)StartOfRound.Instance.currentLevel == (Object)(object)level)
{
TimeOfDay.Instance.currentLevelWeather = weather.VanillaWeatherType;
}
((Logger)Logger).LogDebug($"Changed weather for {ConfigHelper.GetNumberlessName(level)} to {weather.VanillaWeatherType}");
if (!StartOfRound.Instance.inShipPhase)
{
if ((Object)(object)StartOfRound.Instance.currentLevel == (Object)(object)level)
{
((Logger)Logger).LogDebug("Ship has already landed, changing weather effects");
SetWeatherEffects(weather);
return;
}
((Logger)Logger).LogDebug("Ship has already landed - cannot change weather effect on other level!");
}
WeatherManager.CurrentWeathers.SetWeather(level, weather);
((CustomEvent<(SelectableLevel, Weather)>)(object)EventManager.WeatherChanged).Invoke((level, weather));
StartOfRound.Instance.SetMapScreenInfoToCurrentLevel();
}
public static void SetRandomWeathers(SelectableLevel level, List<RandomWeatherWithVariables> randomWeathers)
{
SetRandomWeathers(level, randomWeathers.ToArray());
}
public static void SetRandomWeathers(SelectableLevel level, RandomWeatherWithVariables[] randomWeathers)
{
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
level.randomWeathers = randomWeathers.ToArray();
string alphanumericName = ConfigHelper.GetAlphanumericName(level);
foreach (RandomWeatherWithVariables val in randomWeathers)
{
((Logger)Logger).LogWarning($"Adding random weather {val.weatherType} to {alphanumericName}");
}
}
public static void AddRandomWeather(SelectableLevel level, RandomWeatherWithVariables randomWeather)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Invalid comparison between Unknown and I4
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
List<RandomWeatherWithVariables> list = level.randomWeathers.ToList();
if ((int)randomWeather.weatherType == -1)
{
((Logger)Logger).LogInfo("Cannot add None weather to random weathers, skipping");
return;
}
list.Add(randomWeather);
level.randomWeathers = list.Distinct().ToArray();
Plugin.logger.LogInfo((object)$"Adding random weather {randomWeather.weatherType} to {ConfigHelper.GetAlphanumericName(level)}");
}
public static void RemoveRandomWeather(SelectableLevel level, RandomWeatherWithVariables randomWeather)
{
List<RandomWeatherWithVariables> list = level.randomWeathers.ToList();
list.Remove(randomWeather);
level.randomWeathers = list.ToArray();
}
public static void RemoveRandomWeather(SelectableLevel level, LevelWeatherType weatherType)
{
//IL_0007: 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)
List<RandomWeatherWithVariables> list = level.randomWeathers.Where((RandomWeatherWithVariables rw) => rw.weatherType == weatherType).ToList();
foreach (RandomWeatherWithVariables item in list)
{
RemoveRandomWeather(level, item);
}
}
public static void SetWeatherEffects(LevelWeatherType weatherType)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
WeatherSync.Instance.SetWeatherEffectOnHost(weatherType);
}
public static void SetWeatherEffects(Weather weather)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
SetWeatherEffects(weather.VanillaWeatherType);
}
public static void AddWeatherEffect(LevelWeatherType weatherType)
{
//IL_000a: 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)
Plugin.logger.LogDebug((object)$"Adding weather effect {weatherType}");
List<LevelWeatherType> list = WeatherSync.Instance.Effects.Effects.ToList();
list.Add(weatherType);
WeatherSync.Instance.SetWeatherEffectsOnHost(list.ToArray());
}
public static void AddWeatherEffect(Weather weather)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
AddWeatherEffect(weather.VanillaWeatherType);
}
public static void RemoveWeatherEffect(LevelWeatherType weatherType)
{
//IL_000a: 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)
Plugin.logger.LogDebug((object)$"Removing weather effect {weatherType}");
List<LevelWeatherType> list = WeatherSync.Instance.Effects.Effects.ToList();
list.Remove(weatherType);
WeatherSync.Instance.SetWeatherEffectsOnHost(list.ToArray());
}
}
public static class WeatherEffectController
{
internal static void SetTimeOfDayEffect(LevelWeatherType weatherType, bool enabled)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Invalid comparison between Unknown and I4
//IL_0026: 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_0054: Unknown result type (might be due to invalid IL or missing references)
if ((int)weatherType != -1)
{
if (Settings.IsPlayerInside)
{
Plugin.logger.LogWarning((object)"Player is inside, not setting time of day effect");
}
else if (TimeOfDay.Instance.effects[weatherType] != null)
{
((Logger)Plugin.debugLogger).LogDebug($"Setting time of day effect {weatherType} to {enabled}");
TimeOfDay.Instance.effects[weatherType].effectEnabled = enabled;
}
}
}
[Obsolete("Use SetWeatherEffects(Weather[]) instead")]
public static void SetWeatherEffects(Weather weather)
{
SetWeatherEffects(new Weather[1] { weather });
}
public static void SetWeatherEffects(Weather[] weathers)
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Invalid comparison between Unknown and I4
//IL_007e: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Invalid comparison between Unknown and I4
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0184: Unknown result type (might be due to invalid IL or missing references)
//IL_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
SelectableLevel currentLevel = StartOfRound.Instance.currentLevel;
DisableWeatherEffects(weathers);
foreach (Weather weather2 in weathers)
{
if (weather2 == null)
{
continue;
}
if ((int)weather2.VanillaWeatherType != 4)
{
PlayerControllerB localPlayerController = GameNetworkManager.Instance.localPlayerController;
localPlayerController.isUnderwater = false;
localPlayerController.sourcesCausingSinking = Mathf.Clamp(localPlayerController.sourcesCausingSinking - 1, 0, 100);
localPlayerController.isMovementHindered = Mathf.Clamp(localPlayerController.isMovementHindered - 1, 0, 100);
localPlayerController.hinderedMultiplier = 1f;
}
if ((int)weather2.VanillaWeatherType == -1)
{
SunAnimator.OverrideSunAnimator(weather2.VanillaWeatherType);
continue;
}
if (((CompatibilityBase)Plugin.JLLCompat).IsModPresent)
{
var (flag, val) = Plugin.JLLCompat.GetJLLData();
if (flag)
{
Plugin.logger.LogInfo((object)"Enabling JLL WeatherEffect");
val.effectEnabled = true;
GameObject effectObject = val.effectObject;
if (effectObject != null)
{
effectObject.SetActive(true);
}
continue;
}
}
WeatherEffectOverride effectOverride = weather2.GetEffectOverride(currentLevel);
if (effectOverride == null)
{
weather2.Effect.EffectEnabled = true;
SetTimeOfDayEffect(weather2.VanillaWeatherType, enabled: true);
}
else
{
weather2.Effect.EffectEnabled = false;
effectOverride.OverrideEffect.EffectEnabled = true;
}
}
try
{
SunAnimator.OverrideSunAnimator(weathers.Any((Weather weather) => Defaults.VanillaWeathers.Contains(weather.VanillaWeatherType)) ? weathers.Where((Weather weather) => Defaults.VanillaWeathers.Contains(weather.VanillaWeatherType)).Max((Weather weather) => weather.VanillaWeatherType) : weathers.Max((Weather weather) => weather.VanillaWeatherType));
}
catch (Exception ex)
{
Plugin.logger.LogError((object)("SunAnimator exception: " + ex.Message));
Plugin.logger.LogWarning((object)"PLEASE report this issue to the mod developer with your modpack code and this log!");
}
}
public static void SetWeatherEffects(LevelWeatherType[] weatherTypes)
{
Weather[] weatherEffects = weatherTypes.Select(WeatherManager.GetWeather).ToArray();
SetWeatherEffects(weatherEffects);
}
public static void DisableWeatherEffects(Weather[] newWeathers)
{
foreach (WeatherEffectOverride weatherEffectOverride in OverridesManager.WeatherEffectOverrides)
{
if (!newWeathers.Contains(weatherEffectOverride.Weather))
{
weatherEffectOverride.OverrideEffect.DisableEffect(permament: true);
}
}
foreach (Weather weather in WeatherManager.Weathers)
{
if (!newWeathers.Contains(weather))
{
weather.Effect.DisableEffect(permament: true);
}
}
if (!((CompatibilityBase)Plugin.JLLCompat).IsModPresent)
{
return;
}
var (flag, val) = Plugin.JLLCompat.GetJLLData();
if (flag)
{
Plugin.logger.LogInfo((object)"Disabling JLL WeatherEffect");
val.effectEnabled = false;
GameObject effectObject = val.effectObject;
if (effectObject != null)
{
effectObject.SetActive(false);
}
}
}
public static void EnableCurrentWeatherEffects()
{
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
if (((CompatibilityBase)Plugin.JLLCompat).IsModPresent)
{
var (flag, val) = Plugin.JLLCompat.GetJLLData();
if (flag)
{
Plugin.logger.LogInfo((object)"Enabling JLL WeatherEffect");
val.effectEnabled = true;
GameObject effectObject = val.effectObject;
if (effectObject != null)
{
effectObject.SetActive(true);
}
}
}
foreach (LevelWeatherType currentEffectType in WeatherManager.CurrentEffectTypes)
{
Weather weather = WeatherManager.GetWeather(currentEffectType);
weather.Effect.EffectEnabled = true;
SetTimeOfDayEffect(weather.VanillaWeatherType, enabled: true);
}
}
public static void HandleJLLOverride(LevelWeatherType weatherType, bool enable)
{
if (Plugin.JLLCompat.IsJLLDoingWeatherOverride())
{
Plugin.logger.LogInfo((object)"Detected JLL WeatherOverride");
}
}
}
public static class WeatherManager
{
public static Dictionary<int, Weather> ModdedWeatherEnumExtension = new Dictionary<int, Weather>();
public static CurrentWeathers CurrentWeathers = new CurrentWeathers();
public static bool IsSetupFinished { get; internal set; } = false;
public static List<Weather> RegisteredWeathers { get; internal set; } = new List<Weather>();
public static List<Weather> Weathers => WeathersDictionary.Values.ToList();
public static Dictionary<LevelWeatherType, Weather> WeathersDictionary { get; internal set; } = new Dictionary<LevelWeatherType, Weather>();
public static Weather NoneWeather { get; internal set; }
public static List<LevelWeatherType> LevelWeatherTypes => Weathers.Select((Weather weather) => weather.VanillaWeatherType).ToList();
public static List<LevelWeatherType> CurrentEffectTypes => (from weather in Weathers
where (Object)(object)weather.Effect != (Object)null
where weather.Effect.EffectEnabled
select weather.VanillaWeatherType).ToList();
[Obsolete("Use OverridesManager.WeatherEffectOverrides instead")]
public static List<WeatherEffectOverride> WeatherEffectOverrides => OverridesManager.WeatherEffectOverrides;
public static void RegisterWeather(Weather weather)
{
RegisteredWeathers.Add(weather);
}
public static Weather GetWeather(LevelWeatherType levelWeatherType)
{
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
if (WeathersDictionary.ContainsKey(levelWeatherType))
{
return WeathersDictionary[levelWeatherType];
}
Plugin.logger.LogWarning((object)$"Weather {levelWeatherType} not found in dictionary");
return null;
}
public static List<Weather> GetWeathers()
{
return Weathers;
}
internal static void Reset()
{
IsSetupFinished = false;
Weathers.ForEach(delegate(Weather weather)
{
if (weather.Origin != WeatherOrigin.WeatherRegistry && weather.Origin != WeatherOrigin.WeatherTweaks)
{
Object.Destroy((Object)(object)weather.Effect);
}
});
Weathers.Clear();
WeathersDictionary.Clear();
ModdedWeatherEnumExtension.Clear();
CurrentWeathers.Clear();
OverridesManager.WeatherEffectOverrides.Clear();
Settings.ScreenMapColors.Clear();
ConfigHelper.StringToWeather = null;
RegisteredWeathers.RemoveAll((Weather weather) => weather.Origin != WeatherOrigin.WeatherRegistry && weather.Origin != WeatherOrigin.WeatherTweaks);
WeatherLevelData.LatestWeathersReceived = Array.Empty<WeatherSyncData>();
}
public static string WeatherDisplayOverride(SelectableLevel level)
{
return string.Empty;
}
internal static List<LevelWeatherType> GetPlanetPossibleWeathers(SelectableLevel level)
{
return WeightsManager.GetPlanetPossibleWeathers(level);
}
public static WeightHandler<Weather, WeatherWeightType> GetPlanetWeightedList(SelectableLevel level)
{
return WeightsManager.GetPlanetWeightedList(level);
}
public static (int weight, WeatherWeightType type) GetWeatherWeightForLevel(SelectableLevel level, Weather weather)
{
return WeightsManager.GetWeatherWeightForLevel(level, weather);
}
[Obsolete("Use OverridesManager.GetCurrentWeatherOverride instead")]
public static WeatherEffectOverride GetCurrentWeatherOverride(SelectableLevel level, Weather weather)
{
return OverridesManager.GetCurrentWeatherOverride(level, weather);
}
public static Weather GetCurrentWeather(SelectableLevel level)
{
if (!Settings.SetupFinished)
{
Plugin.logger.LogWarning((object)"Something is trying to get the current weather before setup is finished!");
return null;
}
return CurrentWeathers.GetLevelWeather(level);
}
public static Weather GetCurrentLevelWeather()
{
return GetCurrentWeather(StartOfRound.Instance.currentLevel);
}
public static string GetCurrentWeatherName(SelectableLevel level, bool ignoreOverride = false)
{
string text = WeatherDisplayOverride(level);
if (text != string.Empty && !ignoreOverride)
{
return text;
}
return GetCurrentWeather(level).Name;
}
public static string GetWeatherList()
{
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected I4, but got Unknown
//IL_0035: 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_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: 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
List<WeatherListData> list = new List<WeatherListData>();
foreach (Weather weather in Weathers)
{
list.Add(new WeatherListData
{
WeatherID = FixedString64Bytes.op_Implicit(((int)weather.VanillaWeatherType).ToString()),
WeatherName = FixedString64Bytes.op_Implicit(weather.Name)
});
}
return JsonConvert.SerializeObject((object)list, (Formatting)0, new JsonSerializerSettings
{
ReferenceLoopHandling = (ReferenceLoopHandling)1
});
}
}
public class WeatherResolvable
{
public virtual string WeatherName { get; }
public virtual LevelWeatherType WeatherType { get; }
public override string ToString()
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected I4, but got Unknown
return $"{WeatherName} ({(int)WeatherType})";
}
}
public class WeatherNameResolvable : WeatherResolvable
{
[CompilerGenerated]
private string <weatherName>P;
public override string WeatherName => <weatherName>P;
public override LevelWeatherType WeatherType
{
get
{
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
if (WeatherManager.IsSetupFinished)
{
return (LevelWeatherType)(((??)ConfigHelper.ResolveStringToWeather(<weatherName>P)?.VanillaWeatherType) ?? (-1));
}
((Logger)Plugin.debugLogger).LogDebug("Tried to resolve weather name " + <weatherName>P + " before setup finished");
return (LevelWeatherType)(-1);
}
}
public WeatherNameResolvable(string weatherName)
{
<weatherName>P = weatherName;
base..ctor();
}
}
public class WeatherTypeResolvable : WeatherResolvable
{
[CompilerGenerated]
private LevelWeatherType <weatherType>P;
public override LevelWeatherType WeatherType => <weatherType>P;
public override string WeatherName
{
get
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
if (WeatherManager.IsSetupFinished)
{
return WeatherManager.GetWeather(<weatherType>P).Name;
}
return "";
}
}
public WeatherTypeResolvable(LevelWeatherType weatherType)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
<weatherType>P = weatherType;
base..ctor();
}
}
internal class WeatherSync : NetworkBehaviour
{
private static Logger Logger = new Logger("WeatherSync", (LoggingType)1);
public NetworkVariable<WeatherSyncDataWrapper> WeathersSynced = new NetworkVariable<WeatherSyncDataWrapper>(new WeatherSyncDataWrapper
{
Weathers = Array.Empty<WeatherSyncData>()
}, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
public NetworkVariable<WeatherEffectDataWrapper> EffectsSynced = new NetworkVariable<WeatherEffectDataWrapper>(new WeatherEffectDataWrapper
{
Effects = (LevelWeatherType[])(object)new LevelWeatherType[1] { (LevelWeatherType)(-1) }
}, (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
public NetworkVariable<FixedString4096Bytes> WeatherData = new NetworkVariable<FixedString4096Bytes>(default(FixedString4096Bytes), (NetworkVariableReadPermission)0, (NetworkVariableWritePermission)0);
public static GameObject WeatherSyncPrefab;
public static NetworkManager networkManager;
public static bool networkHasStarted = false;
private static WeatherSync _instance;
private static List<GameObject> queuedNetworkPrefabs = new List<GameObject>();
public WeatherSyncData[] Weather
{
get
{
return WeathersSynced.Value.Weathers;
}
set
{
WeathersSynced.Value = new WeatherSyncDataWrapper
{
Weathers = value
};
}
}
public WeatherEffectDataWrapper Effects
{
get
{
return EffectsSynced.Value;
}
set
{
EffectsSynced.Value = new WeatherEffectDataWrapper
{
Effects = value.Effects
};
}
}
public FixedString4096Bytes WeatherList
{
get
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return WeatherData.Value;
}
set
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
WeatherData.Value = value;
}
}
public static WeatherSync Instance
{
get
{
if ((Object)(object)_instance == (Object)null)
{
_instance = Object.FindObjectOfType<WeatherSync>();
if ((Object)(object)_instance == (Object)null)
{
((Logger)Logger).LogError("WeatherSync instance is null");
}
}
return _instance;
}
private set
{
_instance = value;
}
}
public override void OnNetworkSpawn()
{
((NetworkBehaviour)this).OnNetworkSpawn();
InitializeInstance();
NetworkVariable<WeatherSyncDataWrapper> weathersSynced = WeathersSynced;
weathersSynced.OnValueChanged = (OnValueChangedDelegate<WeatherSyncDataWrapper>)(object)Delegate.Combine((Delegate?)(object)weathersSynced.OnValueChanged, (Delegate?)(object)new OnValueChangedDelegate<WeatherSyncDataWrapper>(WeatherLevelData.WeathersReceived));
NetworkVariable<WeatherEffectDataWrapper> effectsSynced = EffectsSynced;
effectsSynced.OnValueChanged = (OnValueChangedDelegate<WeatherEffectDataWrapper>)(object)Delegate.Combine((Delegate?)(object)effectsSynced.OnValueChanged, (Delegate?)(object)new OnValueChangedDelegate<WeatherEffectDataWrapper>(WeatherEffectData.EffectsReceived));
}
public void SetNewOnHost(Dictionary<string, LevelWeatherType> weathers)
{
if (!((NetworkBehaviour)StartOfRound.Instance).IsHost)
{
((Logger)Logger).LogDebug("Cannot set weathers, not a host!");
return;
}
WeatherSyncData[] weather = weathers.Select(delegate(KeyValuePair<string, LevelWeatherType> kvp)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_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)
WeatherSyncData result = default(WeatherSyncData);
result.Weather = kvp.Value;
result.LevelName = new FixedString64Bytes(kvp.Key);
return result;
}).ToArray();
Weather = weather;
}
public void SetWeatherEffectOnHost(LevelWeatherType weatherType)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000b: Expected I4, but got Unknown
SetWeatherEffectsOnHost((LevelWeatherType[])(object)new LevelWeatherType[1] { (LevelWeatherType)(int)weatherType });
}
public void SetWeatherEffectsOnHost(LevelWeatherType[] weatherTypes)
{
if (!((NetworkBehaviour)StartOfRound.Instance).IsHost)
{
((Logger)Logger).LogDebug("Cannot set effects, not a host!");
return;
}
((Logger)Logger).LogDebug("Setting effects: [" + string.Join("; ", weatherTypes) + "]");
Effects = new WeatherEffectDataWrapper
{
Effects = weatherTypes
};
}
public static void RegisterNetworkPrefab(GameObject prefab)
{
if (!networkHasStarted)
{
((Logger)Logger).LogDebug("Registering NetworkPrefab: " + (object)prefab);
queuedNetworkPrefabs.Add(prefab);
}
else
{
((Logger)Logger).LogWarning("Attempted To Register NetworkPrefab: " + ((object)prefab)?.ToString() + " After GameNetworkManager Has Started!");
}
}
internal static void RegisterPrefabs(NetworkManager networkManager)
{
((Logger)Logger).LogDebug("Registering NetworkPrefabs in NetworkManager");
List<GameObject> existingPrefabs = GetExistingPrefabs(networkManager);
RegisterQueuedPrefabs(networkManager, existingPrefabs);
networkHasStarted = true;
}
private void InitializeInstance()
{
((Object)((Component)this).gameObject).name = "WeatherSync";
Instance = this;
Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
((Logger)Logger).LogDebug($"WeathersSynced: {WeathersSynced.Value}");
}
private static List<GameObject> GetExistingPrefabs(NetworkManager networkManager)
{
List<GameObject> list = new List<GameObject>();
foreach (NetworkPrefab prefab in networkManager.NetworkConfig.Prefabs.m_Prefabs)
{
list.Add(prefab.Prefab);
}
return list;
}
private static void RegisterQueuedPrefabs(NetworkManager networkManager, List<GameObject> addedNetworkPrefabs)
{
int num = 0;
foreach (GameObject queuedNetworkPrefab in queuedNetworkPrefabs)
{
((Logger)Logger).LogDebug("Trying To Register Prefab: " + (object)queuedNetworkPrefab);
if (!addedNetworkPrefabs.Contains(queuedNetworkPrefab))
{
networkManager.AddNetworkPrefab(queuedNetworkPrefab);
addedNetworkPrefabs.Add(queuedNetworkPrefab);
}
else
{
num++;
}
}
((Logger)Logger).LogDebug("Skipped Registering " + num + " NetworkObjects As They Were Already Registered.");
}
protected override void __initializeVariables()
{
if (WeathersSynced == null)
{
throw new Exception("WeatherSync.WeathersSynced cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)WeathersSynced).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)WeathersSynced, "WeathersSynced");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)WeathersSynced);
if (EffectsSynced == null)
{
throw new Exception("WeatherSync.EffectsSynced cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)EffectsSynced).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)EffectsSynced, "EffectsSynced");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)EffectsSynced);
if (WeatherData == null)
{
throw new Exception("WeatherSync.WeatherData cannot be null. All NetworkVariableBase instances must be initialized.");
}
((NetworkVariableBase)WeatherData).Initialize((NetworkBehaviour)(object)this);
((NetworkBehaviour)this).__nameNetworkVariable((NetworkVariableBase)(object)WeatherData, "WeatherData");
base.NetworkVariableFields.Add((NetworkVariableBase)(object)WeatherData);
((NetworkBehaviour)this).__initializeVariables();
}
protected override void __initializeRpcs()
{
((NetworkBehaviour)this).__initializeRpcs();
}
[MethodImpl(MethodImplOptions.NoInlining)]
protected internal override string __getTypeName()
{
return "WeatherSync";
}
}
public class Weather
{
public ImprovedWeatherEffect Effect;
public RegistryWeatherConfig Config = new RegistryWeatherConfig();
internal Dictionary<SelectableLevel, WeatherEffectOverride> WeatherEffectOverrides = new Dictionary<SelectableLevel, WeatherEffectOverride>();
public string Name { get; set; }
public virtual string NameShort
{
get
{
if (Name.Length > 5)
{
return Name.Substring(0, 5);
}
return Name;
}
}
[Obsolete("Use Weather.Name instead")]
public string name => Name;
public LevelWeatherType VanillaWeatherType { get; internal set; } = (LevelWeatherType)(-1);
internal WeatherOrigin Origin { get; set; } = WeatherOrigin.WeatherRegistry;
public WeatherType Type { get; internal set; } = WeatherType.Modded;
public TMP_ColorGradient ColorGradient { get; set; } = ColorConverter.ToTMPColorGradient(Color.cyan);
public Color Color
{
get
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
return ColorGradient.topLeft;
}
[Obsolete("Use Weather.ColorGradient instead")]
set
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
ColorGradient = ColorConverter.ToTMPColorGradient(value);
}
}
public int DefaultWeight => ((ConfigHandler<int, int>)Config.DefaultWeight).Value;
[Obsolete("Use Weather.Config.LevelFilters instead")]
public string[] DefaultLevelFilters => ((ConfigHandler<SelectableLevel[], string>)Config.LevelFilters).DefaultValue.Split(";");
[Obsolete("Use Weather.Config.LevelWeights instead")]
public string[] DefaultLevelWeights => ((ConfigHandler<LevelRarity[], string>)Config.LevelWeights).DefaultValue.Split(";");
[Obsolete("Use Weather.Config.WeatherToWeatherWeights instead")]
public string[] DefaultWeatherToWeatherWeights => ((ConfigHandler<WeatherRarity[], string>)Config.WeatherToWeatherWeights).DefaultValue.Split(";");
public float ScrapAmountMultiplier => ((ConfigHandler<float, float>)Config.ScrapAmountMultiplier).Value;
public float ScrapValueMultiplier => ((ConfigHandler<float, float>)Config.ScrapValueMultiplier).Value;
[SerializeField]
public FilteringOption LevelFilteringOption
{
get
{
if (!((ConfigHandler<bool, bool>)Config.FilteringOption).Value)
{
return FilteringOption.Exclude;
}
return FilteringOption.Include;
}
[Obsolete("Use Weather.Config.FilteringOption instead")]
set
{
Config.FilteringOption = new BooleanConfigHandler(value == FilteringOption.Include);
}
}
public List<SelectableLevel> LevelFilters => ((ConfigHandler<SelectableLevel[], string>)Config.LevelFilters).Value.ToList();
public Dictionary<LevelWeatherType, int> WeatherWeights => ((ConfigHandler<WeatherRarity[], string>)Config.WeatherToWeatherWeights).Value.ToDictionary((WeatherRarity rarity) => rarity.Weather.VanillaWeatherType, (WeatherRarity rarity) => rarity.Weight);
public Dictionary<SelectableLevel, int> LevelWeights => ((ConfigHandler<LevelRarity[], string>)Config.LevelWeights).Value.ToDictionary((LevelRarity rarity) => rarity.Level, (LevelRarity rarity) => rarity.Weight);
public virtual string ConfigCategory => ((Type == WeatherType.Vanilla || Type == WeatherType.Clear) ? "Vanilla" : "Modded") + " Weather: " + Name.Replace(" ", "") + ((Origin != WeatherOrigin.WeatherRegistry && Origin != 0) ? $" ({Origin})" : "");
public Weather(string name = "None", ImprovedWeatherEffect effect = null)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Unknown result type (might be due to invalid IL or missing references)
Regex regex = new Regex("<.*?>");
Name = regex.Replace(name, "");
Effect = effect;
if ((Object)(object)effect != (Object)null)
{
((Object)Effect).name = Name;
}
}
public virtual void Init()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
Config.Init(this);
if ((Object)(object)Effect != (Object)null)
{
Effect.LevelWeatherType = VanillaWeatherType;
}
else
{
Plugin.logger.LogError((object)("Weather " + Name + " has no effect assigned!"));
}
if ((Object)(object)ColorGradient != (Object)null)
{
((Object)ColorGradient).name = "Weather" + GetAlphanumericName();
}
}
public List<RandomWeatherWithVariables> GetRandomWeathers(SelectableLevel level)
{
return level.randomWeathers.Where((RandomWeatherWithVariables rw) => rw.weatherType == VanillaWeatherType).ToList();
}
public override string ToString()
{
return Name;
}
public void RemoveFromMoon(string moonNames)
{
ConfigHelper.ConvertStringToLevels(moonNames).ToList().ForEach(delegate(SelectableLevel level)
{
LevelFilters.Remove(level);
});
}
public void RemoveFromMoon(SelectableLevel moon)
{
LevelFilters.Remove(moon);
}
public (int weight, WeatherWeightType type) GetWeightWithOrigin(SelectableLevel level)
{
//IL_0010: 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)
Logger logger = WeatherCalculation.Logger;
int item = DefaultWeight;
WeatherWeightType weatherWeightType = WeatherWeightType.Default;
Weather weather = WeatherManager.GetWeather(level.currentWeather);
if (weather == null)
{
((Logger)logger).LogError("Previous weather is null for " + ((Object)level).name);
}
int value2;
if (LevelWeights.TryGetValue(level, out var value))
{
weatherWeightType = WeatherWeightType.Level;
item = value;
}
else if (weather.WeatherWeights.TryGetValue(VanillaWeatherType, out value2) && StartOfRound.Instance.gameStats.daysSpent != 0)
{
weatherWeightType = WeatherWeightType.WeatherToWeather;
item = value2;
}
else
{
weatherWeightType = WeatherWeightType.Default;
}
return (item, weatherWeightType);
}
public int GetWeight(SelectableLevel level)
{
return GetWeightWithOrigin(level).weight;
}
public string GetAlphanumericName()
{
return ConfigHelper.GetAlphanumericName(this);
}
public (bool isWTW, int weight) GetWeatherToWeatherWeight(Weather previousWeather)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
if (previousWeather.WeatherWeights.TryGetValue(VanillaWeatherType, out var value))
{
return (true, value);
}
return (false, DefaultWeight);
}
public WeatherEffectOverride GetEffectOverride(SelectableLevel level)
{
if (WeatherEffectOverrides.ContainsKey(level))
{
return WeatherEffectOverrides[level];
}
return null;
}
}
public static class PluginInfo
{
public const string PLUGIN_GUID = "mrov.WeatherRegistry";
public const string PLUGIN_NAME = "WeatherRegistry";
public const string PLUGIN_VERSION = "0.8.8";
}
}
namespace WeatherRegistry.Utils
{
public static class ColorConverter
{
public static TMP_ColorGradient ToTMPColorGradient(Color color)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: 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_002f: 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)
color.a = 1f;
TMP_ColorGradient val = ScriptableObject.CreateInstance<TMP_ColorGradient>();
val.colorMode = (ColorMode)0;
val.topLeft = color;
val.topRight = color;
val.bottomLeft = color;
val.bottomRight = color;
return val;
}
public static TMP_ColorGradient CreateColorGradientInstance()
{
return ScriptableObject.CreateInstance<TMP_ColorGradient>();
}
public static string ToHex(Color color)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
return ColorUtility.ToHtmlStringRGB(color);
}
}
public abstract class ConfigHandler<T, CT> : ConfigHandler<T, CT>
{
public ConfigDescription _configDescription;
public bool _enabled = true;
public bool ConfigEntryActive
{
get
{
if (((ConfigHandler<T, CT>)this).ConfigEntry != null)
{
return Enabled;
}
return false;
}
}
public bool Enabled { get; set; }
}
public class DynamicGradientApplier
{
private class GradientInfo
{
public string content;
public int originalPosition;
public TMP_ColorGradient gradient;
public int tagLength;
}
public TextMeshProUGUI textComponent;
public DynamicGradientApplier(TextMeshProUGUI textComponent)
{
this.textComponent = textComponent;
base..ctor();
}
public void ApplyGradientsFromTags(string text)
{
string pattern = "<gradient=\"?([^\">]+)\"?>(.*?)</gradient>";
string pattern2 = "\\<(?:size|cspace)+(?:\\=[^\\>]*)*?\\>";
MatchCollection matchCollection = Regex.Matches(text, pattern);
if (matchCollection.Count == 0)
{
((TMP_Text)textComponent).text = text;
return;
}
List<GradientInfo> list = new List<GradientInfo>();
foreach (Match item in matchCollection)
{
string value = item.Groups[1].Value;
string value2 = item.Groups[2].Value;
int index = item.Index;
TMP_ColorGradient coloredString = GetColoredString(value);
if ((Object)(object)coloredString != (Object)null)
{
list.Add(new GradientInfo
{
content = value2,
originalPosition = index,
gradient = coloredString,
tagLength = item.Length
});
}
}
string text2 = Regex.Replace(text, pattern, "$2");
((TMP_Text)textComponent).text = text2;
((TMP_Text)textComponent).ForceMeshUpdate(false, false);
int num = Regex.Matches(text, pattern2).Sum((Match m) => m.Length);
foreach (GradientInfo item2 in list)
{
int num2 = item2.originalPosition - num;
int endChar = num2 + item2.content.Length - 1;
ApplyGradient(num2, endChar, item2.gradient);
int num3 = item2.tagLength - item2.content.Length;
num += num3;
}
}
private TMP_ColorGradient GetColoredString(string text)
{
//IL_0115: Unknown result type (might be due to invalid IL or missing references)
//IL_0116: Unknown result type (might be due to invalid IL or missing references)
//IL_011d: 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_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_0127: 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_0130: 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)
//IL_013d: Unknown result type (might be due to invalid IL or missing references)
TMP_ColorGradient value;
TMP_ColorGradient val = (Settings.ScreenMapColors.TryGetValue(text, out value) ? value : ColorConverter.CreateColorGradientInstance());
if ((Object)(object)val != (Object)(object)ColorConverter.CreateColorGradientInstance())
{
Color topLeft = default(Color);
((Color)(ref topLeft))..ctor(val.topLeft.r, val.topLeft.g * 1.1f, val.topLeft.b, val.topLeft.a);
Color topRight = default(Color);
((Color)(ref topRight))..ctor(val.topRight.r, val.topRight.g * 1.1f, val.topRight.b, val.topRight.a);
Color bottomLeft = default(Color);
((Color)(ref bottomLeft))..ctor(val.bottomLeft.r, val.bottomLeft.g * 1.1f, val.bottomLeft.b, val.bottomLeft.a);
Color bottomRight = default(Color);
((Color)(ref bottomRight))..ctor(val.bottomRight.r, val.bottomRight.g * 1.1f, val.bottomRight.b, val.bottomRight.a);
TMP_ColorGradient val2 = ColorConverter.CreateColorGradientInstance();
val2.topLeft = topLeft;
val2.topRight = topRight;
val2.bottomLeft = bottomLeft;
val2.bottomRight = bottomRight;
val2.colorMode = val.colorMode;
((Object)val2).name = ((Object)val).name;
val = val2;
}
((Logger)Plugin.debugLogger).LogDebug("Picked gradient for '" + text + "': " + ((Object)val).name);
return val;
}
private void ApplyGradient(int startChar, int endChar, TMP_ColorGradient gradient)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Invalid comparison between Unknown and I4
//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)
//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_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0045: 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_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Invalid comparison between Unknown and I4
//IL_0059: 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)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
//IL_00db: 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_00e1: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_0104: Unknown result type (might be due to invalid IL or missing references)
TMP_TextInfo textInfo = ((TMP_Text)textComponent).textInfo;
Color topLeft = gradient.topLeft;
Color val = gradient.topRight;
Color val2 = gradient.bottomLeft;
Color val3 = gradient.bottomRight;
if ((int)gradient.colorMode == 0)
{
topLeft = gradient.topLeft;
val = gradient.topLeft;
val2 = gradient.topLeft;
val3 = gradient.topLeft;
}
else if ((int)gradient.colorMode == 1)
{
val2 = topLeft;
val3 = val;
}
else if ((int)gradient.colorMode == 2)
{
val = topLeft;
val3 = val2;
}
for (int i = startChar; i <= endChar && i < textInfo.characterCount; i++)
{
if (textInfo.characterInfo[i].isVisible)
{
int materialReferenceIndex = textInfo.characterInfo[i].materialReferenceIndex;
int vertexIndex = textInfo.characterInfo[i].vertexIndex;
Color32[] colors = textInfo.meshInfo[materialReferenceIndex].colors32;
colors[vertexIndex] = Color32.op_Implicit(val2);
colors[vertexIndex + 1] = Color32.op_Implicit(topLeft);
colors[vertexIndex + 2] = Color32.op_Implicit(val);
colors[vertexIndex + 3] = Color32.op_Implicit(val3);
}
}
((TMP_Text)textComponent).UpdateVertexData((TMP_VertexDataUpdateFlags)16);
}
}
public class WeightHandler<T, OT> : WeightHandler<T>
{
private Dictionary<T, OT> originDict = new Dictionary<T, OT>();
public override Logger logger => (Logger)(object)Plugin.debugLogger;
public OT GetOrigin(T item)
{
if (!originDict.ContainsKey(item))
{
return default(OT);
}
return originDict[item];
}
}
}
namespace WeatherRegistry.Patches
{
[HarmonyPatch(typeof(AudioReverbTrigger))]
public class AudioReverbTriggerPatches
{
private static Logger logger = new Logger("AudioReverbTrigger", (LoggingType)2);
[HarmonyTranspiler]
[HarmonyPatch("ChangeAudioReverbForPlayer")]
internal static IEnumerable<CodeInstruction> ChangeAudioReverbForPlayerPatch(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Expected O, but got Unknown
//IL_0083: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Expected O, but got Unknown
//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
//IL_00b0: Expected O, but got Unknown
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Expected O, but got Unknown
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Expected O, but got Unknown
//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ff: Expected O, but got Unknown
//IL_011c: Unknown result type (might be due to invalid IL or missing references)
//IL_0122: Expected O, but got Unknown
//IL_013f: Unknown result type (might be due to invalid IL or missing references)
//IL_0145: Expected O, but got Unknown
CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
CodeMatcher val2 = val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[7]
{
new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(TimeOfDay), "get_Instance", (Type[])null, (Type[])null), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(TimeOfDay), "effects"), (string)null),
new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(TimeOfDay), "get_Instance", (Type[])null, (Type[])null), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldfld, (object)AccessTools.Field(typeof(TimeOfDay), "currentLevelWeather"), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldelem_Ref, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Stfld, (object)AccessTools.Field(typeof(WeatherEffect), "effectEnabled"), (string)null)
});
val2.RemoveInstructions(7);
val2.Insert((CodeInstruction[])(object)new CodeInstruction[2]
{
new CodeInstruction(OpCodes.Ldarg_0, (object)null),
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(AudioReverbTriggerPatches), "ChangeReverbRegistryCheck", (Type[])null, (Type[])null))
});
return val.InstructionEnumeration();
}
public static void ChangeReverbRegistryCheck(AudioReverbTrigger audioReverbTrigger)
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Invalid comparison between Unknown and I4
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
((Logger)logger).LogWarning("---CheckIfShouldEnable Ran!---");
if (!((Object)(object)audioReverbTrigger == (Object)null) && audioReverbTrigger.enableCurrentLevelWeather && (int)TimeOfDay.Instance.currentLevelWeather != -1)
{
((Logger)logger).LogDebug($"AudioReverbTrigger: {audioReverbTrigger}");
((Logger)logger).LogDebug($"EnableCurrentLevelWeather: {audioReverbTrigger.enableCurrentLevelWeather}");
((Logger)logger).LogDebug($"CurrentLevelWeather: {TimeOfDay.Instance.currentLevelWeather}");
((Logger)logger).LogWarning("Currently enabled effects: " + string.Join(", ", WeatherManager.CurrentEffectTypes));
WeatherEffectController.EnableCurrentWeatherEffects();
}
}
}
public class CodeRebirthPatches
{
[CompilerGenerated]
private sealed class <HandleWRSetupWithOxyde>d__3 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public SelectableLevel level;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <HandleWRSetupWithOxyde>d__3(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<>2__current = (object)new WaitUntil((Func<bool>)(() => WeatherManager.IsSetupFinished));
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (TimeOfDay.Instance.daysUntilDeadline <= 0)
{
WeatherController.ChangeWeather(level, (LevelWeatherType)(-1));
return false;
}
if (!Plugin.ModConfig.ConfigOxydeNeedsNightShift.Value && WeatherManager.GetCurrentWeather(level).Type != 0)
{
return false;
}
Plugin.ExtendedLogging((object)("Switch weather to: " + ((Registry<DawnWeatherEffectInfo>)(object)LethalContent.Weathers)[CodeRebirthWeatherKeys.NightShift].WeatherEffect.name));
Plugin.ExtendedLogging((object)$"LevelweatherType: {(object)(LevelWeatherType)MiscHelpers.IndexOf<WeatherEffect>((IEnumerable<WeatherEffect>)TimeOfDay.Instance.effects, ((Registry<DawnWeatherEffectInfo>)(object)LethalContent.Weathers)[CodeRebirthWeatherKeys.NightShift].WeatherEffect)}");
WeatherController.ChangeWeather(level, (LevelWeatherType)MiscHelpers.IndexOf<WeatherEffect>((IEnumerable<WeatherEffect>)TimeOfDay.Instance.effects, ((Registry<DawnWeatherEffectInfo>)(object)LethalContent.Weathers)[CodeRebirthWeatherKeys.NightShift].WeatherEffect));
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public static void Init()
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Expected O, but got Unknown
Plugin.harmony.Patch((MethodBase)AccessTools.Method("CodeRebirth.src.MiscScripts.WeatherController:Start", (Type[])null, (Type[])null), new HarmonyMethod(typeof(CodeRebirthPatches).GetMethod("StartPrefixPatch")), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
Plugin.logger.LogMessage((object)"Patched CodeRebirth.src.MiscScripts.WeatherController:Start");
Plugin.harmony.Patch((MethodBase)AccessTools.Method("CodeRebirth.src.Util.CodeRebirthUtils:OnNetworkSpawn", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(CodeRebirthPatches).GetMethod("CRUtils_OnNetworkSpawn")), (HarmonyMethod)null, (HarmonyMethod)null);
Plugin.logger.LogMessage((object)"Patched CodeRebirth.src.Util.CodeRebirthUtils:OnNetworkSpawn");
}
public static bool StartPrefixPatch(WeatherController __instance)
{
bool flag = WeatherManager.GetCurrentLevelWeather().Type == WeatherType.Clear;
Plugin.ExtendedLogging((object)$"Weather: {WeatherManager.GetCurrentLevelWeather().Type}, IsClearWeather: {flag}");
if (!flag)
{
((MonoBehaviour)__instance).StartCoroutine(__instance.HandleDarkness());
}
return false;
}
[MethodImpl(MethodImplOptions.NoInlining | MethodImplOptions.NoOptimization)]
public static IEnumerable<CodeInstruction> CRUtils_OnNetworkSpawn(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Expected O, but got Unknown
//IL_0065: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Expected O, but got Unknown
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Expected O, but got Unknown
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Expected O, but got Unknown
//IL_0121: Unknown result type (might be due to invalid IL or missing references)
//IL_0127: Expected O, but got Unknown
//IL_0134: Unknown result type (might be due to invalid IL or missing references)
//IL_013a: Expected O, but got Unknown
//IL_0157: Unknown result type (might be due to invalid IL or missing references)
//IL_015d: Expected O, but got Unknown
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
//IL_016b: Expected O, but got Unknown
CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[6]
{
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method("CodeRebirth.src.Util.CodeRebirthUtils:HandleWRSetupWithOxyde", (Type[])null, (Type[])null), (string)null),
new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(MonoBehaviour), "StartCoroutine", new Type[1] { typeof(IEnumerator) }, (Type[])null), (string)null),
new CodeMatch((OpCode?)OpCodes.Pop, (object)null, (string)null)
});
if (!val.IsValid)
{
Plugin.logger.LogError((object)"CodeRebirth transpiler failed to find StartCoroutine pattern!");
return instructions;
}
val.RemoveInstructions(6);
Type type = AccessTools.TypeByName("Dawn.DawnMoonInfo");
PropertyInfo propertyInfo = AccessTools.Property(type, "Level");
if (propertyInfo == null)
{
Plugin.logger.LogError((object)"Failed to find Dawn.DawnMoonInfo.Level property!");
return instructions;
}
val.Insert((CodeInstruction[])(object)new CodeInstruction[4]
{
new CodeInstruction(OpCodes.Ldloc_0, (object)null),
new CodeInstruction(OpCodes.Callvirt, (object)propertyInfo.GetGetMethod()),
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(CodeRebirthPatches), "HandleWRSetupWithOxyde", (Type[])null, (Type[])null)),
new CodeInstruction(OpCodes.Pop, (object)null)
});
return val.InstructionEnumeration();
}
[IteratorStateMachine(typeof(<HandleWRSetupWithOxyde>d__3))]
private static IEnumerator HandleWRSetupWithOxyde(SelectableLevel level)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <HandleWRSetupWithOxyde>d__3(0)
{
level = level
};
}
}
[HarmonyPatch(typeof(EntranceTeleport))]
internal class EntranceTeleportPatch
{
private static Logger logger = new Logger("EntranceTeleport", (LoggingType)2);
[Obsolete("Use Settings.IsPlayerInside instead")]
internal static bool isPlayerInside => Settings.IsPlayerInside;
[HarmonyPostfix]
[HarmonyPatch(typeof(EntranceTeleport), "TeleportPlayer")]
private static void TeleportPlayerPatch(EntranceTeleport __instance)
{
((Logger)logger).LogDebug("TeleportPlayerPatch called with " + ((Object)__instance).name);
Settings.IsPlayerInside = __instance.isEntranceToBuilding;
if (Settings.IsPlayerInside)
{
((Logger)logger).LogDebug("Player is inside");
return;
}
((Logger)logger).LogDebug("Player is outside");
WeatherEffectController.EnableCurrentWeatherEffects();
}
}
public static class EnumPatches
{
public static string LevelWeatherTypeEnumToStringHook(Func<Enum, string> orig, Enum self)
{
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Expected I4, but got Unknown
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected I4, but got Unknown
if (self.GetType() == typeof(LevelWeatherType) && WeatherManager.ModdedWeatherEnumExtension.ContainsKey((int)(LevelWeatherType)(object)self))
{
return WeatherManager.ModdedWeatherEnumExtension[(int)(LevelWeatherType)(object)self].Name;
}
return orig(self);
}
}
[HarmonyPatch(typeof(GameNetworkManager), "Start")]
internal class GameNetworkManagerStartPatch
{
[HarmonyPrefix]
public static void GameMethodPatch(GameNetworkManager __instance)
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Expected O, but got Unknown
WeatherSync.networkManager = ((Component)__instance).GetComponent<NetworkManager>();
GameObject val = new GameObject("WeatherRegistrySyncInnit");
((Object)val).hideFlags = (HideFlags)61;
val.AddComponent<NetworkObject>();
byte[] value = MD5.Create().ComputeHash(Encoding.UTF8.GetBytes("weatherregistryweathersync"));
val.GetComponent<NetworkObject>().GlobalObjectIdHash = BitConverter.ToUInt32(value, 0);
val.AddComponent<WeatherSync>();
val.GetComponent<NetworkObject>().DontDestroyWithOwner = true;
val.GetComponent<NetworkObject>().SceneMigrationSynchronization = true;
val.GetComponent<NetworkObject>().DestroyWithScene = false;
Object.DontDestroyOnLoad((Object)(object)val);
WeatherSync.WeatherSyncPrefab = val;
WeatherSync.RegisterNetworkPrefab(val);
WeatherSync.RegisterPrefabs(((Component)__instance).GetComponent<NetworkManager>());
((Logger)Plugin.debugLogger).LogDebug("WeatherSync initialized in GameNetworkManager.Start");
}
}
[HarmonyPatch(typeof(GiantKiwiAI))]
public static class GiantKiwiAISpawnPatch
{
[HarmonyPatch("SpawnNestEggs")]
[HarmonyTranspiler]
public static IEnumerable<CodeInstruction> SpawnNestEggsTranspiler(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0022: Expected O, but got Unknown
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Expected O, but got Unknown
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005e: Expected O, but got Unknown
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0092: Expected O, but got Unknown
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Expected O, but got Unknown
CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
{
new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloc_1, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloc_2, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null)
});
if (val.IsInvalid)
{
Plugin.logger.LogError((object)"Failed to find SpawnEggsClientRpc call in SpawnNestEggs!");
return instructions;
}
val.Insert((CodeInstruction[])(object)new CodeInstruction[2]
{
new CodeInstruction(OpCodes.Ldloc_2, (object)null),
new CodeInstruction(OpCodes.Call, (object)AccessTools.Method(typeof(GiantKiwiAISpawnPatch), "AdjustEggValuesForWeather", (Type[])null, (Type[])null))
});
Plugin.logger.LogDebug((object)"Successfully patched SpawnNestEggs with weather multiplier adjustment!");
return val.InstructionEnumeration();
}
private static void AdjustEggValuesForWeather(int[] eggScrapValues)
{
Weather currentLevelWeather = WeatherManager.GetCurrentLevelWeather();
Plugin.logger.LogDebug((object)$"Adjusting {eggScrapValues.Length} eggs with weather multiplier {currentLevelWeather.ScrapValueMultiplier}");
for (int i = 0; i < eggScrapValues.Length; i++)
{
int num = eggScrapValues[i];
eggScrapValues[i] = Mathf.CeilToInt((float)eggScrapValues[i] * currentLevelWeather.ScrapValueMultiplier);
Plugin.logger.LogDebug((object)$"Egg {i}: {num} -> {eggScrapValues[i]}");
}
}
}
public static class ImperiumPatches
{
public static class ImperiumMoonManagerPatches
{
public static bool RefreshWeatherEffectsPrefixPatch()
{
return false;
}
}
public static class ImperiumPlayerManagerPatch
{
public static void TeleportPlayerPrefixPatch(TeleportPlayerRequest request)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
((Logger)Plugin.debugLogger).LogDebug($"TeleportPlayer called with playerId: {((TeleportPlayerRequest)(ref request)).PlayerId} and destination: {((TeleportPlayerRequest)(ref request)).Destination}");
((Logger)Plugin.debugLogger).LogDebug($"Is player script inside? {StartOfRound.Instance.allPlayerScripts[((TeleportPlayerRequest)(ref request)).PlayerId].isInsideFactory}");
}
public static IEnumerable<CodeInstruction> TeleportPlayerTranspilerPatch(IEnumerable<CodeInstruction> instructions)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Expected O, but got Unknown
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Expected O, but got Unknown
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Expected O, but got Unknown
CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
{
new CodeMatch((OpCode?)OpCodes.Call, (object)AccessTools.Method(typeof(TimeOfDay), "get_Instance", (Type[])null, (Type[])null), (string)null),
new CodeMatch((OpCode?)OpCodes.Ldc_I4_0, (object)null, (string)null),
new CodeMatch((OpCode?)OpCodes.Callvirt, (object)AccessTools.Method(typeof(TimeOfDay), "DisableAllWeather", (Type[])null, (Type[])null), (string)null)
});
val.RemoveInstructions(3);
return val.InstructionEnumeration();
}
public static void TeleportPlayerPostfixPatch(TeleportPlayerRequest request)
{
((Logger)Plugin.debugLogger).LogDebug($"Postfix: Is player script inside? {StartOfRound.Instance.allPlayerScripts[((TeleportPlayerRequest)(ref request)).PlayerId].isInsideFactory}");
Settings.IsPlayerInside = StartOfRound.Instance.allPlayerScripts[((TeleportPlayerRequest)(ref request)).PlayerId].isInsideFactory;
if (Settings.IsPlayerInside)
{
((Logger)Plugin.debugLogger).LogDebug("Player is inside, disabling all weather effects.");
TimeOfDay.Instance.DisableAllWeather(false);
}
