using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
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 HarmonyLib;
using JetBrains.Annotations;
using LocalizationManager;
using Microsoft.CodeAnalysis;
using ServerSync;
using TMPro;
using UnityEngine;
using UnityEngine.UI;
using YamlDotNet.Serialization;
[assembly: Guid("E0E2F92E-557C-4A05-9D89-AA92A0BD75C4")]
[assembly: ComVisible(false)]
[assembly: AssemblyTrademark("")]
[assembly: AssemblyCopyright("Copyright © 2022")]
[assembly: AssemblyProduct("Seasonality")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyTitle("Seasonality")]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: CompilationRelaxations(8)]
[assembly: AssemblyFileVersion("3.8.0")]
[assembly: AssemblyCompany("RustyMods")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("3.8.0.0")]
[module: <ae650d74-94f2-479b-8dd0-feb21e5725ca>RefSafetyRules(11)]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[<3e1f5bd2-754e-4a19-b0c5-f7a086bba6bc>Embedded]
internal sealed class <3e1f5bd2-754e-4a19-b0c5-f7a086bba6bc>EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[<3e1f5bd2-754e-4a19-b0c5-f7a086bba6bc>Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class <e20e6f32-22c3-4b84-81bd-a666c1d7c470>NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public <e20e6f32-22c3-4b84-81bd-a666c1d7c470>NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public <e20e6f32-22c3-4b84-81bd-a666c1d7c470>NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[<3e1f5bd2-754e-4a19-b0c5-f7a086bba6bc>Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class <3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContextAttribute : Attribute
{
public readonly byte Flag;
public <3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[<3e1f5bd2-754e-4a19-b0c5-f7a086bba6bc>Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class <ae650d74-94f2-479b-8dd0-feb21e5725ca>RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public <ae650d74-94f2-479b-8dd0-feb21e5725ca>RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace LocalizationManager
{
[PublicAPI]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
public class Localizer
{
private static readonly Dictionary<string, Dictionary<string, Func<string>>> PlaceholderProcessors;
private static readonly Dictionary<string, Dictionary<string, string>> loadedTexts;
private static readonly ConditionalWeakTable<Localization, string> localizationLanguage;
private static readonly List<WeakReference<Localization>> localizationObjects;
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(2)]
private static BaseUnityPlugin _plugin;
private static readonly List<string> fileExtensions;
private static BaseUnityPlugin plugin
{
get
{
//IL_009d: Unknown result type (might be due to invalid IL or missing references)
//IL_00a7: Expected O, but got Unknown
if (_plugin == null)
{
IEnumerable<TypeInfo> source;
try
{
source = Assembly.GetExecutingAssembly().DefinedTypes.ToList();
}
catch (ReflectionTypeLoadException ex)
{
source = from t in ex.Types
where t != null
select t.GetTypeInfo();
}
_plugin = (BaseUnityPlugin)Chainloader.ManagerObject.GetComponent((Type)source.First([<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)] (TypeInfo t) => t.IsClass && typeof(BaseUnityPlugin).IsAssignableFrom(t)));
}
return _plugin;
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(2)]
[method: <3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(2)]
[field: <e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(2)]
public static event Action OnLocalizationComplete;
private static void UpdatePlaceholderText(Localization localization, string key)
{
localizationLanguage.TryGetValue(localization, out var value);
string text = loadedTexts[value][key];
if (PlaceholderProcessors.TryGetValue(key, out var value2))
{
text = value2.Aggregate(text, [<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)] (string current, KeyValuePair<string, Func<string>> kv) => current.Replace("{" + kv.Key + "}", kv.Value()));
}
localization.AddWord(key, text);
}
public static void AddPlaceholder<T>(string key, string placeholder, ConfigEntry<T> config, [<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(new byte[] { 2, 1, 1 })] Func<T, string> convertConfigValue = null)
{
if (convertConfigValue == null)
{
convertConfigValue = (T val) => val.ToString();
}
if (!PlaceholderProcessors.ContainsKey(key))
{
PlaceholderProcessors[key] = new Dictionary<string, Func<string>>();
}
config.SettingChanged += [<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)] (object _, EventArgs _) =>
{
UpdatePlaceholder();
};
if (loadedTexts.ContainsKey(Localization.instance.GetSelectedLanguage()))
{
UpdatePlaceholder();
}
void UpdatePlaceholder()
{
PlaceholderProcessors[key][placeholder] = () => convertConfigValue(config.Value);
UpdatePlaceholderText(Localization.instance, key);
}
}
public static void AddText(string key, string text)
{
List<WeakReference<Localization>> list = new List<WeakReference<Localization>>();
foreach (WeakReference<Localization> localizationObject in localizationObjects)
{
if (localizationObject.TryGetTarget(out var target))
{
Dictionary<string, string> dictionary = loadedTexts[localizationLanguage.GetOrCreateValue(target)];
if (!target.m_translations.ContainsKey(key))
{
dictionary[key] = text;
target.AddWord(key, text);
}
}
else
{
list.Add(localizationObject);
}
}
foreach (WeakReference<Localization> item in list)
{
localizationObjects.Remove(item);
}
}
public static void Load()
{
_ = plugin;
}
public static void LoadLocalizationLater(Localization __instance)
{
LoadLocalization(Localization.instance, __instance.GetSelectedLanguage());
}
public static void SafeCallLocalizeComplete()
{
Localizer.OnLocalizationComplete?.Invoke();
}
private static void LoadLocalization(Localization __instance, string language)
{
//IL_0174: Unknown result type (might be due to invalid IL or missing references)
//IL_017e: Expected O, but got Unknown
//IL_021a: Unknown result type (might be due to invalid IL or missing references)
//IL_0224: Expected O, but got Unknown
if (!localizationLanguage.Remove(__instance))
{
localizationObjects.Add(new WeakReference<Localization>(__instance));
}
localizationLanguage.Add(__instance, language);
Dictionary<string, string> dictionary = new Dictionary<string, string>();
foreach (string item in from f in Directory.GetFiles(Path.GetDirectoryName(Paths.PluginPath), plugin.Info.Metadata.Name + ".*", SearchOption.AllDirectories)
where fileExtensions.IndexOf(Path.GetExtension(f)) >= 0
select f)
{
string[] array = Path.GetFileNameWithoutExtension(item).Split(new char[1] { '.' });
if (array.Length >= 2)
{
string text = array[1];
if (dictionary.ContainsKey(text))
{
Debug.LogWarning((object)("Duplicate key " + text + " found for " + plugin.Info.Metadata.Name + ". The duplicate file found at " + item + " will be skipped."));
}
else
{
dictionary[text] = item;
}
}
}
byte[] array2 = LoadTranslationFromAssembly("English");
if (array2 == null)
{
throw new Exception("Found no English localizations in mod " + plugin.Info.Metadata.Name + ". Expected an embedded resource translations/English.json or translations/English.yml.");
}
Dictionary<string, string> dictionary2 = ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).IgnoreFields().Build().Deserialize<Dictionary<string, string>>(Encoding.UTF8.GetString(array2));
if (dictionary2 == null)
{
throw new Exception("Localization for mod " + plugin.Info.Metadata.Name + " failed: Localization file was empty.");
}
string text2 = null;
if (language != "English")
{
if (dictionary.TryGetValue(language, out var value))
{
text2 = File.ReadAllText(value);
}
else
{
byte[] array3 = LoadTranslationFromAssembly(language);
if (array3 != null)
{
text2 = Encoding.UTF8.GetString(array3);
}
}
}
if (text2 == null && dictionary.TryGetValue("English", out var value2))
{
text2 = File.ReadAllText(value2);
}
if (text2 != null)
{
foreach (KeyValuePair<string, string> item2 in ((BuilderSkeleton<DeserializerBuilder>)new DeserializerBuilder()).IgnoreFields().Build().Deserialize<Dictionary<string, string>>(text2) ?? new Dictionary<string, string>())
{
dictionary2[item2.Key] = item2.Value;
}
}
loadedTexts[language] = dictionary2;
foreach (KeyValuePair<string, string> item3 in dictionary2)
{
UpdatePlaceholderText(__instance, item3.Key);
}
}
static Localizer()
{
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0054: Expected O, but got Unknown
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Expected O, but got Unknown
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Expected O, but got Unknown
//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Expected O, but got Unknown
PlaceholderProcessors = new Dictionary<string, Dictionary<string, Func<string>>>();
loadedTexts = new Dictionary<string, Dictionary<string, string>>();
localizationLanguage = new ConditionalWeakTable<Localization, string>();
localizationObjects = new List<WeakReference<Localization>>();
fileExtensions = new List<string>(2) { ".json", ".yml" };
Harmony val = new Harmony("org.bepinex.helpers.LocalizationManager");
val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(Localization), "SetupLanguage", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalization", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "SetupGui", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "LoadLocalizationLater", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
val.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Start", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(Localizer), "SafeCallLocalizeComplete", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
}
[return: <e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(2)]
private static byte[] LoadTranslationFromAssembly(string language)
{
foreach (string fileExtension in fileExtensions)
{
byte[] array = ReadEmbeddedFileBytes("translations." + language + fileExtension);
if (array != null)
{
return array;
}
}
return null;
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(2)]
public static byte[] ReadEmbeddedFileBytes([<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)] string resourceFileName, Assembly containingAssembly = null)
{
using MemoryStream memoryStream = new MemoryStream();
if ((object)containingAssembly == null)
{
containingAssembly = Assembly.GetCallingAssembly();
}
string text = containingAssembly.GetManifestResourceNames().FirstOrDefault([<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)] (string str) => str.EndsWith(resourceFileName, StringComparison.Ordinal));
if (text != null)
{
containingAssembly.GetManifestResourceStream(text)?.CopyTo(memoryStream);
}
return (memoryStream.Length == 0L) ? null : memoryStream.ToArray();
}
}
public static class LocalizationManagerVersion
{
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
public const string Version = "1.4.1";
}
}
namespace Seasonality
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public class SeasonalIce : MonoBehaviour
{
private static GameObject Ice = null;
private static readonly ZoneVegetation ZoneVeg = new ZoneVegetation();
private static readonly List<SeasonalIce> m_instances = new List<SeasonalIce>();
private Destructible m_destructible;
public void Awake()
{
m_destructible = ((Component)this).GetComponent<Destructible>();
m_instances.Add(this);
((MonoBehaviour)this).InvokeRepeating("CheckSeason", 0f, 10f);
}
public void OnDestroy()
{
m_instances.Remove(this);
}
public void CheckSeason()
{
if (Configs.m_season.Value != Season.Winter)
{
m_destructible.DestroyNow();
}
}
public static void UpdateAll()
{
foreach (SeasonalIce instance in m_instances)
{
instance.CheckSeason();
}
}
public static void UpdateZoneVeg()
{
if (!Object.op_Implicit((Object)(object)ZoneSystem.instance))
{
return;
}
if (Configs.m_season.Value == Season.Winter && Configs.m_addIceShelves.Value == Toggle.On)
{
if (!ZoneSystem.instance.m_vegetation.Contains(ZoneVeg))
{
ZoneSystem.instance.m_vegetation.Add(ZoneVeg);
}
}
else
{
ZoneSystem.instance.m_vegetation.Remove(ZoneVeg);
}
}
public static void Setup()
{
Clone clone = new Clone("ice1", "SeasonalIce");
clone.OnCreated += delegate(GameObject p)
{
//IL_0049: 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)
p.AddComponent<SeasonalIce>();
ZoneVeg.m_name = "SeasonalIce";
ZoneVeg.m_prefab = p;
ZoneVeg.m_min = 10f;
ZoneVeg.m_max = 20f;
ZoneVeg.m_biome = (Biome)539;
ZoneVeg.m_biomeArea = (BiomeArea)3;
ZoneVeg.m_blockCheck = true;
ZoneVeg.m_minAltitude = -1000f;
ZoneVeg.m_maxAltitude = -1f;
UpdateZoneVeg();
Ice = p;
};
}
}
public class RandomColors : MonoBehaviour
{
[HarmonyPatch(typeof(ZNetScene), "Awake")]
private static class ZNetScene_Awake_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(ZNetScene __instance)
{
foreach (string name in new StringListConfig(Configs.m_fallObjects.Value).m_names)
{
GameObject prefab = __instance.GetPrefab(name);
if (prefab != null)
{
prefab.AddComponent<RandomColors>();
m_modifiedPrefabs.Add(prefab);
}
}
Configs.m_fallObjects.SettingChanged += delegate
{
RandomColors randomColors = default(RandomColors);
foreach (GameObject modifiedPrefab in m_modifiedPrefabs)
{
if (modifiedPrefab.TryGetComponent<RandomColors>(ref randomColors))
{
Object.Destroy((Object)(object)randomColors);
}
}
m_modifiedPrefabs.Clear();
foreach (string name2 in new StringListConfig(Configs.m_fallObjects.Value).m_names)
{
GameObject prefab2 = __instance.GetPrefab(name2);
if (prefab2 != null)
{
prefab2.AddComponent<RandomColors>();
m_modifiedPrefabs.Add(prefab2);
}
}
};
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(new byte[] { 2, 1 })]
public Renderer[] m_renderers;
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(2)]
public ParticleSystem m_particleSystem;
public MinMaxGradient m_originalGradient;
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
public static readonly List<RandomColors> m_instances = new List<RandomColors>();
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
private static readonly List<GameObject> m_modifiedPrefabs = new List<GameObject>();
public void Awake()
{
if (Configs.m_randomColors.Value != 0 && new StringListConfig(Configs.m_fallObjects.Value).m_names.Contains(((Object)this).name.Replace("(Clone)", string.Empty)))
{
m_renderers = ((Component)this).GetComponentsInChildren<Renderer>(true);
m_particleSystem = ((Component)this).GetComponentInChildren<ParticleSystem>();
m_instances.Add(this);
}
}
public void Start()
{
//IL_00be: Unknown result type (might be due to invalid IL or missing references)
//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
if (m_renderers != null)
{
Renderer[] renderers = m_renderers;
foreach (Renderer val in renderers)
{
if (val.sharedMaterials == null)
{
continue;
}
Material[] sharedMaterials = val.sharedMaterials;
for (int j = 0; j < sharedMaterials.Length; j++)
{
if (!((Object)(object)sharedMaterials[j] == (Object)null))
{
string key = ((Object)sharedMaterials[j]).name.Replace("(Instance)", string.Empty).Trim();
if (TextureReplacer.m_fallMaterials.TryGetValue(key, out var value))
{
sharedMaterials[j] = value[Random.Range(0, value.Count)].m_material;
}
}
}
val.sharedMaterials = sharedMaterials;
}
}
if ((Object)(object)m_particleSystem != (Object)null)
{
MainModule main = m_particleSystem.main;
m_originalGradient = ((MainModule)(ref main)).startColor;
}
UpdateParticleColors();
}
public void OnDestroy()
{
m_instances.Remove(this);
}
public static void UpdateAll()
{
foreach (RandomColors instance in m_instances)
{
instance.UpdateParticleColors();
}
}
public void UpdateParticleColors()
{
//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_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: 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_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
if (Configs.m_particlesController.Value != 0 && !((Object)(object)m_particleSystem == (Object)null))
{
MainModule main = m_particleSystem.main;
m_originalGradient = ((MainModule)(ref main)).startColor;
MinMaxGradient startColor;
switch (Configs.m_season.Value)
{
case Season.Fall:
startColor = default(MinMaxGradient);
((MinMaxGradient)(ref startColor)).color = Color32.op_Implicit(new Color32((byte)205, (byte)92, (byte)92, byte.MaxValue));
((MinMaxGradient)(ref startColor)).colorMax = Color32.op_Implicit(new Color32((byte)218, (byte)165, (byte)32, byte.MaxValue));
((MinMaxGradient)(ref startColor)).colorMin = Color32.op_Implicit(new Color32((byte)233, (byte)116, (byte)81, byte.MaxValue));
((MinMaxGradient)(ref startColor)).mode = (ParticleSystemGradientMode)4;
((MainModule)(ref main)).startColor = startColor;
break;
case Season.Winter:
startColor = default(MinMaxGradient);
((MinMaxGradient)(ref startColor)).color = Color.white;
((MinMaxGradient)(ref startColor)).mode = (ParticleSystemGradientMode)0;
((MainModule)(ref main)).startColor = startColor;
break;
default:
((MainModule)(ref main)).startColor = m_originalGradient;
break;
}
}
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public class FrozenWaterLOD : MonoBehaviour
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(Game), "Start")]
private static class Game_Start_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(Game __instance)
{
if (!Object.op_Implicit((Object)(object)__instance))
{
return;
}
try
{
((Component)Utils.FindChild(((Component)__instance).gameObject.transform, "WaterPlane", (IterativeSearchType)0).GetChild(0)).gameObject.AddComponent<FrozenWaterLOD>();
}
catch
{
SeasonalityPlugin.Record.LogDebug("Failed to find water LOD");
}
}
}
public Vector3 m_originalPos;
public MeshRenderer m_renderer;
public Material m_originalMat;
public bool m_frozen;
private static readonly List<FrozenWaterLOD> Instances = new List<FrozenWaterLOD>();
public static void UpdateAll()
{
foreach (FrozenWaterLOD instance in Instances)
{
if (Configs.m_season.Value == Season.Winter && Configs.m_waterFreezes.Value == Toggle.On)
{
instance.Freeze();
}
else
{
instance.Thaw();
}
}
}
public void Awake()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
m_originalPos = ((Component)this).transform.position;
m_renderer = ((Component)this).GetComponent<MeshRenderer>();
m_originalMat = ((Renderer)m_renderer).material;
SetInitialValues();
Instances.Add(this);
}
private void SetInitialValues()
{
//IL_0082: 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_0053: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
if (Object.op_Implicit((Object)(object)m_renderer))
{
if (Configs.m_waterFreezes.Value == Toggle.On && Configs.m_season.Value == Season.Winter)
{
((Renderer)m_renderer).material = SeasonalityPlugin.FrozenWaterMat1;
((Component)this).transform.position = m_originalPos + new Vector3(0f, -0.2f, 0f);
m_frozen = true;
}
else
{
((Renderer)m_renderer).material = m_originalMat;
((Component)this).transform.position = m_originalPos;
m_frozen = false;
}
}
}
public void OnDestroy()
{
Instances.Remove(this);
}
public void Thaw()
{
//IL_0021: Unknown result type (might be due to invalid IL or missing references)
if (m_frozen)
{
((Renderer)m_renderer).material = m_originalMat;
((Component)this).transform.position = m_originalPos;
m_frozen = false;
}
}
public void Freeze()
{
//IL_0020: 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_0039: Unknown result type (might be due to invalid IL or missing references)
if (!m_frozen)
{
((Renderer)m_renderer).material = SeasonalityPlugin.FrozenWaterMat1;
((Component)this).transform.position = m_originalPos + new Vector3(0f, -0.2f, 0f);
m_frozen = true;
}
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public class FrozenZones : MonoBehaviour
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(ZoneSystem), "Start")]
private static class ZoneSystem_Start_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(ZoneSystem __instance)
{
if (Object.op_Implicit((Object)(object)__instance))
{
__instance.m_zonePrefab.AddComponent<FrozenZones>();
}
}
}
public MeshCollider m_surfaceCollider;
public MeshRenderer m_surfaceRenderer;
public WaterVolume m_waterVolume;
public Material m_originalMaterial;
private static readonly List<FrozenZones> Instances = new List<FrozenZones>();
public bool m_frozen;
public static void UpdateAll()
{
foreach (FrozenZones instance in Instances)
{
if (Configs.m_waterFreezes.Value == Toggle.Off)
{
instance.ThawWater();
}
else if (Configs.m_season.Value == Season.Winter)
{
instance.FreezeWater();
}
else
{
instance.ThawWater();
}
}
}
public void Awake()
{
Transform val = ((Component)this).transform.Find("Water");
Transform val2 = val.Find("WaterSurface");
Transform val3 = val.Find("WaterVolume");
MeshFilter component = ((Component)val2).GetComponent<MeshFilter>();
m_surfaceRenderer = ((Component)val2).GetComponent<MeshRenderer>();
m_waterVolume = ((Component)val3).GetComponent<WaterVolume>();
m_surfaceCollider = ((Component)val2).gameObject.AddComponent<MeshCollider>();
m_originalMaterial = ((Renderer)m_surfaceRenderer).material;
m_surfaceCollider.sharedMesh = component.sharedMesh;
SetInitialValues();
if (!Instances.Contains(this))
{
Instances.Add(this);
}
}
public void OnDestroy()
{
Instances.Remove(this);
}
private void SetInitialValues()
{
if (Configs.m_season.Value == Season.Winter && Configs.m_waterFreezes.Value == Toggle.On)
{
((Renderer)m_surfaceRenderer).material = SeasonalityPlugin.FrozenWaterMat1;
((Collider)m_surfaceCollider).enabled = true;
m_waterVolume.m_useGlobalWind = false;
m_frozen = true;
}
else
{
((Renderer)m_surfaceRenderer).material = m_originalMaterial;
((Collider)m_surfaceCollider).enabled = false;
m_waterVolume.m_useGlobalWind = true;
m_frozen = false;
}
}
public void FreezeWater()
{
if (Object.op_Implicit((Object)(object)m_surfaceCollider) && Object.op_Implicit((Object)(object)m_surfaceCollider) && Object.op_Implicit((Object)(object)m_waterVolume) && !m_frozen)
{
((Renderer)m_surfaceRenderer).material = SeasonalityPlugin.FrozenWaterMat1;
((Collider)m_surfaceCollider).enabled = true;
m_waterVolume.m_useGlobalWind = false;
m_frozen = true;
}
}
public void ThawWater()
{
if (Object.op_Implicit((Object)(object)m_surfaceCollider) && Object.op_Implicit((Object)(object)m_surfaceCollider) && Object.op_Implicit((Object)(object)m_waterVolume) && m_frozen)
{
((Renderer)m_surfaceRenderer).material = m_originalMaterial;
((Collider)m_surfaceCollider).enabled = false;
m_waterVolume.m_useGlobalWind = true;
m_waterVolume.Start();
m_frozen = false;
}
}
}
public static class GlobalKeyManager
{
public static void UpdateSeasonalKey()
{
if (Object.op_Implicit((Object)(object)ZoneSystem.instance))
{
ClearSeasonalKeys();
SetKey();
}
}
private static void ClearSeasonalKeys()
{
if (!Object.op_Implicit((Object)(object)ZoneSystem.instance))
{
return;
}
foreach (string item in ZoneSystem.instance.GetGlobalKeys().ToList())
{
if (item.StartsWith("season_"))
{
ZoneSystem.instance.RemoveGlobalKey(item);
}
}
}
private static void SetKey()
{
if (Object.op_Implicit((Object)(object)ZoneSystem.instance))
{
ZoneSystem.instance.SetGlobalKey("season_" + Configs.m_season.Value.ToString().ToLower());
}
}
}
public class MossController : MonoBehaviour
{
[HarmonyPatch(typeof(BossStone), "Start")]
private static class BossStone_Start_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(BossStone __instance)
{
if (Object.op_Implicit((Object)(object)__instance) && !Object.op_Implicit((Object)(object)((Component)__instance).GetComponentInParent<LocationFix>()))
{
MossController mossController = ((Component)__instance).gameObject.AddComponent<MossController>();
mossController.Cache();
mossController.SetMoss();
}
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
private readonly Dictionary<Material, Texture> m_textureMap = new Dictionary<Material, Texture>();
private static readonly int MossTex = Shader.PropertyToID("_MossTex");
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
private static readonly List<MossController> m_instances = new List<MossController>();
public static void UpdateAll()
{
foreach (MossController instance in m_instances)
{
instance.SetMoss();
}
}
public void Awake()
{
m_instances.Add(this);
}
public void OnDestroy()
{
m_instances.Remove(this);
}
private void Cache()
{
Renderer[] componentsInChildren = ((Component)this).gameObject.GetComponentsInChildren<Renderer>();
if (componentsInChildren.Length == 0)
{
return;
}
Renderer[] array = componentsInChildren;
foreach (Renderer val in array)
{
Material[] sharedMaterials = val.sharedMaterials;
foreach (Material val2 in sharedMaterials)
{
if (!((Object)(object)val2 == (Object)null) && val2.HasProperty(MossTex))
{
Texture tex = TextureManager.stonemoss.m_tex;
if (tex != null)
{
m_textureMap[val2] = tex;
}
else
{
m_textureMap[val2] = val2.GetTexture(MossTex);
}
}
}
}
}
public void SetMoss()
{
switch (Configs.m_season.Value)
{
case Season.Fall:
{
foreach (KeyValuePair<Material, Texture> item in m_textureMap)
{
item.Key.SetTexture(MossTex, TextureManager.Stonemoss_heath.m_tex);
}
return;
}
case Season.Winter:
{
foreach (KeyValuePair<Material, Texture> item2 in m_textureMap)
{
item2.Key.SetTexture(MossTex, TextureManager.AshOnRocks_d.m_tex);
}
return;
}
}
foreach (KeyValuePair<Material, Texture> item3 in m_textureMap)
{
item3.Key.SetTexture(MossTex, item3.Value);
}
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public class LocationFix : MonoBehaviour
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(ZoneSystem), "SpawnLocation")]
private static class ZoneSystem_SpawnLocation_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(ref GameObject __result)
{
if (Object.op_Implicit((Object)(object)__result))
{
__result.AddComponent<LocationFix>();
}
}
}
public static readonly List<LocationFix> m_instances = new List<LocationFix>();
public Renderer[] m_renderers;
public readonly Dictionary<Material, Texture> m_textures = new Dictionary<Material, Texture>();
private static readonly int MossTex = Shader.PropertyToID("_MossTex");
private Texture TryGetOriginalMoss(Texture current)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: 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)
//IL_0018: Invalid comparison between Unknown and I4
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Invalid comparison between Unknown and I4
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001c: Invalid comparison between Unknown and I4
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Invalid comparison between Unknown and I4
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Invalid comparison between Unknown and I4
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Invalid comparison between Unknown and I4
Biome biome = WorldGenerator.instance.GetBiome(((Component)this).transform.position);
Texture val;
if ((int)biome <= 2)
{
if ((int)biome == 1)
{
goto IL_0037;
}
if ((int)biome != 2)
{
goto IL_0093;
}
val = TextureManager.stonemoss_swamp.m_tex;
}
else
{
if ((int)biome == 8)
{
goto IL_0037;
}
if ((int)biome != 16)
{
if ((int)biome != 512)
{
goto IL_0093;
}
val = (((Object)((Component)this).transform).name.ToLower().Contains("dvergr") ? TextureManager.groundcreep_d.m_tex : TextureManager.stonemoss_bw.m_tex);
}
else
{
val = TextureManager.Stonemoss_heath.m_tex;
}
}
goto IL_009e;
IL_009e:
if (!((Object)(object)val != (Object)null))
{
return current;
}
return val;
IL_0037:
val = TextureManager.stonemoss.m_tex;
goto IL_009e;
IL_0093:
val = TextureManager.stonemoss.m_tex;
goto IL_009e;
}
public void Awake()
{
m_renderers = ((Component)this).GetComponentsInChildren<Renderer>();
m_instances.Add(this);
if (m_renderers.Length == 0)
{
return;
}
Renderer[] renderers = m_renderers;
foreach (Renderer val in renderers)
{
Material[] sharedMaterials = val.sharedMaterials;
for (int j = 0; j < val.sharedMaterials.Length; j++)
{
Material val2 = val.sharedMaterials[j];
if (val2.HasProperty(MossTex))
{
m_textures[val2] = TryGetOriginalMoss(val2.GetTexture(MossTex));
}
if (((Object)val2).name.Contains("HildirsLox") && TextureReplacer.m_materials.TryGetValue("lox", out var value))
{
sharedMaterials[j] = value.m_material;
}
}
val.sharedMaterials = sharedMaterials;
}
UpdateMoss();
}
public void OnDestroy()
{
m_instances.Remove(this);
}
public void UpdateMoss()
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0016: Invalid comparison between Unknown and I4
if ((int)WorldGenerator.instance.GetBiome(((Component)this).transform.position) == 4)
{
return;
}
switch (Configs.m_season.Value)
{
case Season.Winter:
{
foreach (Material key in m_textures.Keys)
{
key.SetTexture(MossTex, TextureManager.AshOnRocks_d.m_tex);
}
return;
}
case Season.Fall:
{
foreach (Material key2 in m_textures.Keys)
{
key2.SetTexture(MossTex, TextureManager.Stonemoss_heath.m_tex);
}
return;
}
}
foreach (KeyValuePair<Material, Texture> texture in m_textures)
{
texture.Key.SetTexture(MossTex, texture.Value);
}
}
public static void UpdateAll()
{
foreach (LocationFix instance in m_instances)
{
instance.UpdateMoss();
}
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
public static class SeasonSE
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(ObjectDB), "Awake")]
private static class ObjectDB_Awake_Patch
{
private static void Postfix()
{
if (Object.op_Implicit((Object)(object)ObjectDB.instance) && Object.op_Implicit((Object)(object)ZNetScene.instance))
{
SE_Season sE_Season = ScriptableObject.CreateInstance<SE_Season>();
((Object)sE_Season).name = "SE_Seasons";
((StatusEffect)sE_Season).m_name = "Seasonality";
((StatusEffect)sE_Season).m_icon = GetIcon();
if (!ObjectDB.instance.m_StatusEffects.Contains((StatusEffect)(object)sE_Season))
{
ObjectDB.instance.m_StatusEffects.Add((StatusEffect)(object)sE_Season);
}
}
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public class SE_Season : StatusEffect
{
public override void Setup(Character character)
{
Update();
((StatusEffect)this).Setup(character);
}
public void Update()
{
base.m_name = ((Configs.m_displayType.Value == DisplayType.Above) ? GetSeasonName() : "");
base.m_icon = ((Configs.m_displaySeason.Value == Toggle.On) ? GetIcon() : null);
}
public override string GetTooltipString()
{
StringBuilder stringBuilder = new StringBuilder();
string text = Localization.instance.Localize("$season_" + Configs.m_season.Value.ToString().ToLower() + "_tooltip");
if (!text.Contains("["))
{
stringBuilder.Append("$season_" + Configs.m_season.Value.ToString().ToLower() + "_tooltip\n");
}
stringBuilder.Append("Modifiers Enabled: " + Configs.m_enableModifiers.Value.ToString() + "\n");
stringBuilder.Append(GetToolTip("Carry Weight", "$se_max_carryweight"));
stringBuilder.Append(GetToolTip("Health Regeneration", "$se_healthregen"));
stringBuilder.Append(GetToolTip("Damage", "$se_damage"));
stringBuilder.Append(GetToolTip("Speed", "$item_movement_modifier"));
stringBuilder.Append(GetToolTip("Eitr Regeneration", "$se_eitrregen"));
stringBuilder.Append(GetToolTip("Raise Skill", "$se_skill_modifier"));
stringBuilder.Append(GetToolTip("Stamina Regeneration", "$se_staminaregen"));
return Localization.instance.Localize(stringBuilder.ToString());
}
private string GetToolTip(string key, string token)
{
if (!Configs.m_effectConfigs.TryGetValue(Configs.m_season.Value, out var value))
{
return "";
}
if (!value.TryGetValue(key, out var value2))
{
return "";
}
return FormatTooltip(token, value2, key == "Carry Weight");
}
private string FormatTooltip(string token, [<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(2)] ConfigEntry<float> config, bool integer)
{
float num = ((!integer) ? (config?.Value ?? 1f) : (config?.Value ?? 0f));
string text = ((integer ? (num > 0f) : (num > 1f)) ? "+" : "");
string text2 = (integer ? "" : "%");
float num2 = (integer ? num : (num * 100f - 100f));
if (num2 == 0f)
{
return "";
}
return $"{token}: <color=orange>{text}{Math.Round(num2, 1)}{text2}</color>\n";
}
public override string GetIconText()
{
if (!Object.op_Implicit((Object)(object)EnvMan.instance))
{
return "";
}
if (Configs.m_displayTimer.Value != 0)
{
if (Configs.m_displayType.Value != 0)
{
return GetSeasonName() + "\n" + GetSeasonTime();
}
return GetSeasonTime();
}
if (Configs.m_displayType.Value != 0)
{
return GetSeasonName();
}
return "";
}
private static string GetSeasonName()
{
return Localization.instance.Localize("$season_" + Configs.m_season.Value.ToString().ToLower());
}
public override void ModifyStaminaRegen(ref float staminaRegen)
{
if (Configs.m_enableModifiers.Value != 0)
{
staminaRegen *= Configs.m_effectConfigs.GetOrDefault(Configs.m_season.Value, "Stamina Regeneration", 1f);
}
}
public override void ModifyMaxCarryWeight(float baseLimit, ref float limit)
{
if (Configs.m_enableModifiers.Value != 0)
{
limit += Configs.m_effectConfigs.GetOrDefault("Carry Weight", 0f);
}
}
public override void ModifyRaiseSkill(SkillType skill, ref float value)
{
if (Configs.m_enableModifiers.Value != 0)
{
value *= Configs.m_effectConfigs.GetOrDefault("Raise Skill", 1f);
}
}
public override void ModifyEitrRegen(ref float eitrRegen)
{
if (Configs.m_enableModifiers.Value != 0)
{
eitrRegen *= Configs.m_effectConfigs.GetOrDefault("Eitr Regeneration", 1f);
}
}
public override void ModifyHealthRegen(ref float regenMultiplier)
{
if (Configs.m_enableModifiers.Value != 0)
{
regenMultiplier *= Configs.m_effectConfigs.GetOrDefault("Health Regeneration", 1f);
}
}
public override void ModifyAttack(SkillType skill, ref HitData hitData)
{
if (Configs.m_enableModifiers.Value != 0)
{
hitData.ApplyModifier(Configs.m_effectConfigs.GetOrDefault("Damage", 1f));
}
}
public override void ModifySpeed(float baseSpeed, ref float speed, Character character, Vector3 dir)
{
if (Configs.m_enableModifiers.Value != 0)
{
speed *= Configs.m_effectConfigs.GetOrDefault("Speed", 1f);
}
}
public override void OnDamaged(HitData hit, Character attacker)
{
if (FadeToBlack.m_fading && Configs.m_fadeToBlackImmune.Value == Toggle.On)
{
hit.ApplyModifier(0f);
}
}
}
private const string SE_Seasons = "SE_Seasons";
private static readonly int SE_Season_StableHashCode = StringExtensionMethods.GetStableHashCode("SE_Seasons");
private static float m_timer;
public static void CheckOrSet(float dt)
{
m_timer += dt;
if (!(m_timer <= 10f))
{
m_timer = 0f;
if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && !((Character)Player.m_localPlayer).GetSEMan().HaveStatusEffect(SE_Season_StableHashCode))
{
((Character)Player.m_localPlayer).GetSEMan().AddStatusEffect(SE_Season_StableHashCode, false, 0, 0f);
}
}
}
public static void UpdateStatus()
{
if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && ((Character)Player.m_localPlayer).GetSEMan().GetStatusEffect(SE_Season_StableHashCode) is SE_Season sE_Season)
{
sE_Season.Update();
}
}
private static bool ShouldCount()
{
return GetTotalSeconds() > 0.0;
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(2)]
private static Sprite GetIcon()
{
return (Sprite)(Configs.m_season.Value switch
{
Season.Spring => SpriteManager.SpringIcon,
Season.Summer => SpriteManager.SummerIcon,
Season.Fall => SpriteManager.FallIcon,
Season.Winter => SpriteManager.WinterIcon,
_ => SpriteManager.ValknutIcon,
});
}
private static double GetTotalSeconds()
{
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
ConfigEntry<Vector3> value;
Vector3 val = (Configs.m_durations.TryGetValue(Configs.m_season.Value, out value) ? value.Value : Vector3.zero);
double num = val.x * 86400f;
double num2 = val.y * 3600f;
double num3 = val.z * 60f;
return num + num2 + num3;
}
public static void OnSeasonDisplayConfigChange(object sender, EventArgs e)
{
if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Object.op_Implicit((Object)(object)Hud.instance))
{
if (((Character)Player.m_localPlayer).GetSEMan().GetStatusEffect(SE_Season_StableHashCode) is SE_Season sE_Season)
{
sE_Season.Update();
}
if (Hud.instance.m_tempStatusEffects.Find([<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)] (StatusEffect x) => x.m_nameHash == SE_Season_StableHashCode) is SE_Season sE_Season2)
{
sE_Season2.Update();
}
}
}
private static string GetSeasonTime()
{
if (!ShouldCount())
{
return "";
}
TimeSpan timeSpan = TimeSpan.FromSeconds(SeasonalTimer.GetTimeDifference());
int days = timeSpan.Days;
int hours = timeSpan.Hours;
int minutes = timeSpan.Minutes;
int seconds = timeSpan.Seconds;
if (SeasonalTimer.m_sleepOverride)
{
return Localization.instance.Localize("$msg_ready");
}
if (days <= 0)
{
if (hours <= 0)
{
if (minutes <= 0)
{
return $"{seconds}";
}
return $"{minutes}:{seconds:D2}";
}
return $"{hours}:{minutes:D2}:{seconds:D2}";
}
return string.Format("{0} {1}", days, Localization.instance.Localize((days > 1) ? "$label_days" : "$label_day"));
}
}
public class TerrainController : MonoBehaviour
{
[HarmonyPatch(typeof(Heightmap), "Awake")]
private static class Heightmap_Awake_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(Heightmap __instance)
{
((Component)__instance).gameObject.AddComponent<TerrainController>();
}
}
[HarmonyPatch(typeof(Heightmap), "OnEnable")]
private static class Heightmap_OnEnable_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(Heightmap __instance)
{
TerrainController terrainController = default(TerrainController);
if (((Component)__instance).TryGetComponent<TerrainController>(ref terrainController))
{
terrainController.Load();
}
}
}
[HarmonyPatch(typeof(Heightmap), "OnDisable")]
private static class Heightmap_OnDisable_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(Heightmap __instance)
{
TerrainController item = default(TerrainController);
if (((Component)__instance).TryGetComponent<TerrainController>(ref item))
{
m_instances.Remove(item);
}
}
}
[HarmonyPatch(typeof(Heightmap), "GetBiomeColor", new Type[] { typeof(Biome) })]
private static class Heightmap_GetBiomeColor_Patch
{
private static void Postfix(Biome biome, ref Color32 __result)
{
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Invalid comparison between Unknown and I4
//IL_004d: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Invalid comparison between Unknown and I4
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0025: Invalid comparison between Unknown and I4
//IL_0017: 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: Invalid comparison between Unknown and I4
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: 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_002d: Invalid comparison between Unknown and I4
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Invalid comparison between Unknown and I4
switch (Configs.m_season.Value)
{
case Season.Winter:
if ((int)biome <= 8)
{
if (biome - 1 > 1 && (int)biome != 8)
{
break;
}
}
else if ((int)biome != 16 && (int)biome != 512)
{
break;
}
__result = defaultMap[(Biome)4];
break;
case Season.Fall:
if ((int)biome == 1)
{
__result = defaultMap[(Biome)16];
}
break;
}
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
private static readonly List<TerrainController> m_instances = new List<TerrainController>();
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(2)]
private Heightmap m_heightmap;
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
private static readonly Dictionary<Biome, Color32> defaultMap = new Dictionary<Biome, Color32>
{
{
(Biome)1,
new Color32((byte)0, (byte)0, (byte)0, (byte)0)
},
{
(Biome)8,
new Color32((byte)0, (byte)0, byte.MaxValue, (byte)0)
},
{
(Biome)2,
new Color32(byte.MaxValue, (byte)0, (byte)0, (byte)0)
},
{
(Biome)4,
new Color32((byte)0, byte.MaxValue, (byte)0, (byte)0)
},
{
(Biome)16,
new Color32((byte)0, (byte)0, (byte)0, byte.MaxValue)
},
{
(Biome)512,
new Color32((byte)0, (byte)0, byte.MaxValue, byte.MaxValue)
},
{
(Biome)64,
new Color32((byte)0, byte.MaxValue, (byte)0, (byte)0)
},
{
(Biome)32,
new Color32(byte.MaxValue, (byte)0, (byte)0, byte.MaxValue)
},
{
(Biome)256,
new Color32((byte)0, (byte)0, (byte)0, (byte)0)
}
};
public static void UpdateTerrain()
{
foreach (TerrainController instance in m_instances)
{
if (!((Object)(object)instance == (Object)null) && !((Object)(object)instance.m_heightmap == (Object)null))
{
instance.ChangeTerrainColor();
}
}
}
public void OnDestroy()
{
m_instances.Remove(this);
}
public void Load()
{
m_heightmap = ((Component)this).GetComponent<Heightmap>();
m_instances.Add(this);
}
public void ChangeTerrainColor()
{
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Unknown result type (might be due to invalid IL or missing references)
//IL_0194: Unknown result type (might be due to invalid IL or missing references)
//IL_0199: 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_0146: Unknown result type (might be due to invalid IL or missing references)
//IL_016c: Unknown result type (might be due to invalid IL or missing references)
//IL_0171: Unknown result type (might be due to invalid IL or missing references)
//IL_0178: Unknown result type (might be due to invalid IL or missing references)
//IL_017a: Unknown result type (might be due to invalid IL or missing references)
if (WorldGenerator.instance == null || (Object)(object)m_heightmap == (Object)null || (Object)(object)m_heightmap.m_renderMesh == (Object)null)
{
return;
}
Heightmap.s_tempColors.Clear();
Vector3 val = ((Component)this).transform.position + new Vector3((float)((double)m_heightmap.m_width * (double)m_heightmap.m_scale * -0.5), 0f, (float)((double)m_heightmap.m_width * (double)m_heightmap.m_scale * -0.5));
int num = m_heightmap.m_width + 1;
for (int i = 0; i < num; i++)
{
float num2 = DUtils.SmoothStep(0f, 1f, (float)i / (float)m_heightmap.m_width);
for (int j = 0; j < num; j++)
{
float num3 = DUtils.SmoothStep(0f, 1f, (float)j / (float)m_heightmap.m_width);
Heightmap.s_tempUVs.Add(new Vector2((float)j / (float)m_heightmap.m_width, (float)i / (float)m_heightmap.m_width));
if (m_heightmap.m_isDistantLod)
{
float num4 = val.x + (float)j * m_heightmap.m_scale;
float num5 = val.z + (float)i * m_heightmap.m_scale;
Biome biome = WorldGenerator.instance.GetBiome(num4, num5, 0.02f, false);
Heightmap.s_tempColors.Add(Heightmap.GetBiomeColor(biome));
}
else
{
Heightmap.s_tempColors.Add(Color32.op_Implicit(m_heightmap.GetBiomeColor(num3, num2)));
}
}
}
m_heightmap.m_renderMesh.SetColors(Heightmap.s_tempColors);
}
}
[RequireComponent(typeof(VisEquipment))]
[RequireComponent(typeof(Player))]
public class VisEquipController : MonoBehaviour
{
[HarmonyPatch(typeof(Player), "Awake")]
private static class Player_Awake_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(Player __instance)
{
((Component)__instance).gameObject.AddComponent<VisEquipController>();
}
}
[HarmonyPatch(typeof(VisEquipment), "SetChestEquipped")]
private static class VisEquipment_SetChestEquipped_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(VisEquipment __instance, bool __result)
{
VisEquipController visEquipController = default(VisEquipController);
if (__result && ((Component)__instance).TryGetComponent<VisEquipController>(ref visEquipController))
{
visEquipController.UpdateChestTexture();
}
}
}
[HarmonyPatch(typeof(VisEquipment), "SetLegEquipped")]
private static class VisEquipment_SetLegsEquipped_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(VisEquipment __instance, bool __result)
{
VisEquipController visEquipController = default(VisEquipController);
if (__result && ((Component)__instance).TryGetComponent<VisEquipController>(ref visEquipController))
{
visEquipController.UpdateLegTexture();
}
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
public static readonly List<VisEquipController> m_instances = new List<VisEquipController>();
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
public static VisEquipment m_visEquipment = null;
private static readonly int ChestTex = Shader.PropertyToID("_ChestTex");
private static readonly int LegsTex = Shader.PropertyToID("_LegsTex");
public void Awake()
{
m_visEquipment = ((Component)this).GetComponent<VisEquipment>();
m_instances.Add(this);
}
public void OnDestroy()
{
m_instances.Remove(this);
}
public void UpdatePlayerMaterial()
{
UpdateChestTexture();
UpdateLegTexture();
}
public void UpdateChestTexture()
{
if ((Object)(object)m_visEquipment == (Object)null || (Object)(object)m_visEquipment.m_bodyModel == (Object)null)
{
return;
}
GameObject itemPrefab = ObjectDB.m_instance.GetItemPrefab(m_visEquipment.m_currentChestItemHash);
ItemDrop val = default(ItemDrop);
if (itemPrefab == null || !itemPrefab.TryGetComponent<ItemDrop>(ref val))
{
return;
}
Material armorMaterial = val.m_itemData.m_shared.m_armorMaterial;
if (armorMaterial == null)
{
return;
}
string key = ((Object)armorMaterial).name.Replace("(Instance)", string.Empty).Trim();
if (TextureReplacer.m_materials.TryGetValue(key, out var value) && value.m_specialTextures.TryGetValue("_ChestTex", out var value2))
{
Texture value4;
if (value2.TryGetValue(Configs.m_season.Value, out var value3))
{
((Renderer)m_visEquipment.m_bodyModel).material.SetTexture(ChestTex, value3);
}
else if (value.m_originalTextures.TryGetValue("_ChestTex", out value4))
{
((Renderer)m_visEquipment.m_bodyModel).material.SetTexture(ChestTex, value4);
}
}
}
public void UpdateLegTexture()
{
if ((Object)(object)m_visEquipment == (Object)null || (Object)(object)m_visEquipment.m_bodyModel == (Object)null)
{
return;
}
GameObject itemPrefab = ObjectDB.m_instance.GetItemPrefab(m_visEquipment.m_currentLegItemHash);
ItemDrop val = default(ItemDrop);
if (itemPrefab == null || !itemPrefab.TryGetComponent<ItemDrop>(ref val))
{
return;
}
Material armorMaterial = val.m_itemData.m_shared.m_armorMaterial;
if (armorMaterial == null)
{
return;
}
string key = ((Object)armorMaterial).name.Replace("(Instance)", string.Empty).Trim();
if (TextureReplacer.m_materials.TryGetValue(key, out var value) && value.m_specialTextures.TryGetValue("_LegsTex", out var value2))
{
Texture value4;
if (value2.TryGetValue(Configs.m_season.Value, out var value3))
{
((Renderer)m_visEquipment.m_bodyModel).material.SetTexture(LegsTex, value3);
}
else if (value.m_originalTextures.TryGetValue("_LegsTex", out value4))
{
((Renderer)m_visEquipment.m_bodyModel).material.SetTexture(LegsTex, value4);
}
}
}
public static void UpdateAll()
{
foreach (VisEquipController instance in m_instances)
{
instance.UpdatePlayerMaterial();
}
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public static class WeatherManager
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(EnvMan), "GetAvailableEnvironments")]
private static class GetAvailableEnvironments_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(Biome biome, ref List<EnvEntry> __result)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Invalid comparison between Unknown and I4
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
if (Configs.m_weatherEnabled.Value != 0 && (((int)biome != 0 && (int)biome != 32) || 1 == 0))
{
__result = GetEnvironments(biome, __result);
}
}
}
[HarmonyPatch(typeof(EnvMan), "Awake")]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
private static class EnvMan_Awake_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(EnvMan __instance)
{
if (Object.op_Implicit((Object)(object)__instance))
{
RegisterEnvironments(__instance);
if (Configs.m_weatherEnabled.Value != 0)
{
__instance.m_environmentDuration = Configs.m_weatherDuration.Value * 60;
}
}
}
}
[HarmonyPatch(typeof(EnvMan), "IsCold")]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
private static class EnvMan_IsCold_Patch
{
private static void Postfix(ref bool __result)
{
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Invalid comparison between Unknown and I4
if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && Configs.m_winterAlwaysCold.Value != 0 && Configs.m_season.Value == Season.Winter && (int)Player.m_localPlayer.GetCurrentBiome() != 32)
{
__result = true;
}
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(ObjectDB), "Awake")]
private static class ObjectDB_Awake_Patch
{
private static void Postfix()
{
if (Object.op_Implicit((Object)(object)ObjectDB.instance) && Object.op_Implicit((Object)(object)ZNetScene.instance))
{
SE_WeatherMan sE_WeatherMan = ScriptableObject.CreateInstance<SE_WeatherMan>();
((Object)sE_WeatherMan).name = "SE_Weatherman";
((StatusEffect)sE_WeatherMan).m_name = "Weatherman";
((StatusEffect)sE_WeatherMan).m_icon = SpriteManager.ValknutIcon;
if (!ObjectDB.instance.m_StatusEffects.Contains((StatusEffect)(object)sE_WeatherMan))
{
ObjectDB.instance.m_StatusEffects.Add((StatusEffect)(object)sE_WeatherMan);
}
}
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public class SE_WeatherMan : StatusEffect
{
public override void Setup(Character character)
{
((StatusEffect)this).Setup(character);
Update();
}
public void Update()
{
base.m_icon = ((Configs.m_displayWeather.Value == Toggle.On) ? SpriteManager.ValknutIcon : null);
}
public override string GetTooltipString()
{
string text = Localization.instance.Localize("$weather_" + EnvMan.instance.m_currentEnv.m_name.ToLower().Replace(" ", "_") + "_tooltip");
if (text.Contains("["))
{
text = "";
}
return base.m_tooltip + text;
}
public override string GetIconText()
{
if ((Object)(object)EnvMan.instance == (Object)null)
{
return "";
}
string name = EnvMan.instance.m_currentEnv.m_name;
string text = Localization.instance.Localize("$weather_" + EnvMan.instance.m_currentEnv.m_name.ToLower().Replace(" ", "_"));
base.m_name = (text.Contains("[") ? name : text);
if (Configs.m_displayWeatherTimer.Value == Toggle.Off)
{
return "";
}
double num = EnvMan.instance.m_totalSeconds / (double)EnvMan.instance.m_environmentDuration;
double num2 = 1.0 - (num - Math.Truncate(num));
double num3 = num2 * (double)EnvMan.instance.m_environmentDuration;
int hours = TimeSpan.FromSeconds(num3).Hours;
int minutes = TimeSpan.FromSeconds(num3).Minutes;
int seconds = TimeSpan.FromSeconds(num3).Seconds;
if (num3 < 0.0)
{
return "";
}
if (hours <= 0)
{
if (minutes <= 0)
{
return $"{seconds}";
}
return $"{minutes}:{seconds:D2}";
}
return $"{hours}:{minutes:D2}:{seconds:D2}";
}
}
private const string SE_Weather = "SE_Weatherman";
private static readonly int SE_Weather_StableHashCode = StringExtensionMethods.GetStableHashCode("SE_Weatherman");
private static float m_timer;
private static void RegisterEnvironments(EnvMan __instance)
{
EnvSetup env = __instance.GetEnv("Snow");
EnvSetup env2 = __instance.GetEnv("SnowStorm");
if (env != null && env2 != null)
{
EnvSetup val = env.Clone();
val.m_isFreezing = false;
val.m_isFreezingAtNight = false;
val.m_name = "WarmSnow";
EnvSetup val2 = env2.Clone();
val2.m_isFreezing = false;
val2.m_isFreezingAtNight = false;
val2.m_name = "WarmSnowStorm";
EnvSetup val3 = env.Clone();
val3.m_isFreezing = false;
val3.m_name = "NightFrost";
val3.m_isFreezingAtNight = true;
RegisterEnv(val);
RegisterEnv(val2);
RegisterEnv(val3);
}
}
private static void RegisterEnv(EnvSetup setup)
{
if (Object.op_Implicit((Object)(object)EnvMan.instance) && !EnvMan.instance.m_environments.Contains(setup))
{
EnvMan.instance.m_environments.Add(setup);
}
}
public static void OnWeatherDurationChange(object sender, EventArgs e)
{
if (Object.op_Implicit((Object)(object)EnvMan.instance) && Configs.m_weatherEnabled.Value != 0)
{
EnvMan.instance.m_environmentDuration = Configs.m_weatherDuration.Value * 60;
}
}
private static List<EnvEntry> GetEnvironments(Biome biome, List<EnvEntry> entries)
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00ab: Expected O, but got Unknown
if (!Object.op_Implicit((Object)(object)EnvMan.instance))
{
return entries;
}
List<EnvEntry> list = new List<EnvEntry>();
if (!Configs.m_weatherOptions.TryGetValue(Configs.m_season.Value, out var value))
{
return entries;
}
if (!value.TryGetValue(biome, out var value2))
{
return entries;
}
if (Utility.IsNullOrWhiteSpace(value2.Value))
{
return entries;
}
foreach (WeatherConfig.WeatherData environment in new WeatherConfig(value2.Value).environments)
{
EnvSetup env = EnvMan.instance.GetEnv(environment.name);
if (env != null)
{
EnvEntry item = new EnvEntry
{
m_environment = environment.name,
m_weight = environment.weight,
m_env = env
};
list.Add(item);
}
}
if (list.Count <= 0)
{
return entries;
}
return list;
}
public static void OnDisplayConfigChange(object sender, EventArgs e)
{
if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && ((Character)Player.m_localPlayer).GetSEMan().GetStatusEffect(SE_Weather_StableHashCode) is SE_WeatherMan sE_WeatherMan)
{
sE_WeatherMan.Update();
}
}
public static void CheckOrSet(float dt)
{
if (Configs.m_displayWeather.Value == Toggle.Off)
{
return;
}
m_timer += dt;
if (!(m_timer < 10f))
{
m_timer = 0f;
if (Object.op_Implicit((Object)(object)Player.m_localPlayer) && !((Character)Player.m_localPlayer).GetSEMan().HaveStatusEffect(SE_Weather_StableHashCode))
{
((Character)Player.m_localPlayer).GetSEMan().AddStatusEffect(SE_Weather_StableHashCode, false, 0, 0f);
}
}
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public static class BeeHiveTweaks
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(Beehive), "Interact")]
private static class Beehive_Interact_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static bool Prefix(Beehive __instance, Humanoid character)
{
switch (Configs.m_season.Value)
{
case Season.Summer:
if (SummerEnabled.Value == Toggle.Off)
{
((Character)character).Message((MessageType)2, __instance.m_areaText, 0, (Sprite)null);
return false;
}
return true;
case Season.Fall:
if (FallEnabled.Value == Toggle.Off)
{
((Character)character).Message((MessageType)2, __instance.m_areaText, 0, (Sprite)null);
return false;
}
return true;
case Season.Spring:
if (SpringEnabled.Value == Toggle.Off)
{
((Character)character).Message((MessageType)2, __instance.m_areaText, 0, (Sprite)null);
return false;
}
return true;
case Season.Winter:
if (WinterEnabled.Value == Toggle.Off)
{
((Character)character).Message((MessageType)2, __instance.m_areaText, 0, (Sprite)null);
return false;
}
return true;
default:
return true;
}
}
}
private static ConfigEntry<Toggle> SummerEnabled;
private static ConfigEntry<Toggle> FallEnabled;
private static ConfigEntry<Toggle> SpringEnabled;
private static ConfigEntry<Toggle> WinterEnabled;
public static void Setup()
{
SummerEnabled = ConfigManager.config("Tweaks", "Beehive Summer", Toggle.On, "If on, beehive interactable during summer");
FallEnabled = ConfigManager.config("Tweaks", "Beehive Fall", Toggle.On, "If on, beehive interactable during fall");
SpringEnabled = ConfigManager.config("Tweaks", "Beehive Spring", Toggle.On, "If on, beehive interactable during spring");
WinterEnabled = ConfigManager.config("Tweaks", "Beehive Winter", Toggle.On, "If on, beehive interactable during winter");
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
public static class BuildTweaks
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(PieceTable), "UpdateAvailable")]
private static class PieceTable_UpdateAvailable
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(PieceTable __instance, Player player)
{
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Invalid comparison between Unknown and I4
//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
//IL_00f6: Expected I4, but got Unknown
if (m_enabled.Value == Toggle.Off)
{
return;
}
Piece component = default(Piece);
foreach (string name in new StringListConfig(GetConfig().Value).m_names)
{
GameObject prefab = ZNetScene.instance.GetPrefab(name);
if (prefab == null || !prefab.TryGetComponent<Piece>(ref component) || !player.HaveRequirements(component, (RequirementMode)2))
{
continue;
}
if ((int)component.m_category == 100)
{
foreach (List<Piece> item in __instance.m_availablePieces.Where((List<Piece> list) => !list.Contains(component)))
{
item.Add(component);
}
}
else
{
List<Piece> list2 = __instance.m_availablePieces[(int)component.m_category];
if (!list2.Contains(component))
{
list2.Add(component);
}
}
}
}
}
private static ConfigEntry<Toggle> m_enabled = null;
private static ConfigEntry<string> m_winterPieces = null;
private static ConfigEntry<string> m_springPieces = null;
private static ConfigEntry<string> m_fallPieces = null;
private static ConfigEntry<string> m_summerPieces = null;
private static readonly List<string> m_defaultWinterPieces = new List<string> { "piece_xmascrown", "piece_xmastree", "piece_xmasgarland", "piece_mistletoe", "piece_gift1", "piece_gift2", "piece_gift3" };
private static readonly List<string> m_defaultSpringPieces = new List<string>();
private static readonly List<string> m_defaultFallPieces = new List<string> { "piece_jackoturnip" };
private static readonly List<string> m_defaultSummerPieces = new List<string> { "piece_maypole" };
public static void Setup()
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Expected O, but got Unknown
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Expected O, but got Unknown
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Expected O, but got Unknown
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Expected O, but got Unknown
m_enabled = ConfigManager.config("Tweaks", "Build Pieces Enabled", Toggle.Off, "If on, seasonal build pieces enabled");
m_winterPieces = ConfigManager.config("Tweaks", "Winter Pieces", new StringListConfig(m_defaultWinterPieces).ToString(), new ConfigDescription("Set added winter pieces", (AcceptableValueBase)null, new object[1] { StringListConfig.attributes }));
m_springPieces = ConfigManager.config("Tweaks", "Spring Pieces", new StringListConfig(m_defaultSpringPieces).ToString(), new ConfigDescription("Set added spring pieces", (AcceptableValueBase)null, new object[1] { StringListConfig.attributes }));
m_fallPieces = ConfigManager.config("Tweaks", "Fall Pieces", new StringListConfig(m_defaultFallPieces).ToString(), new ConfigDescription("Set added fall pieces", (AcceptableValueBase)null, new object[1] { StringListConfig.attributes }));
m_summerPieces = ConfigManager.config("Tweaks", "Summer Pieces", new StringListConfig(m_defaultSummerPieces).ToString(), new ConfigDescription("Set added summer pieces", (AcceptableValueBase)null, new object[1] { StringListConfig.attributes }));
}
private static ConfigEntry<string> GetConfig()
{
return (ConfigEntry<string>)(Configs.m_season.Value switch
{
Season.Summer => m_summerPieces,
Season.Spring => m_springPieces,
Season.Fall => m_fallPieces,
Season.Winter => m_winterPieces,
_ => m_summerPieces,
});
}
}
public static class FishTweaks
{
[HarmonyPatch(typeof(Fish), "Interact")]
private static class Fish_Interact_Patch
{
private static bool Prefix()
{
if (m_enabled.Value == Toggle.Off)
{
return true;
}
return Configs.m_season.Value != Season.Winter;
}
}
[HarmonyPatch(typeof(Fish), "GetHoverText")]
private static class Fish_GetHoverText_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(ref string __result)
{
if (m_enabled.Value != 0 && Configs.m_season.Value == Season.Winter)
{
__result += Localization.instance.Localize("\n $cannot_pick");
}
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
private static ConfigEntry<Toggle> m_enabled;
public static void Setup()
{
m_enabled = ConfigManager.config("Tweaks", "Frozen Fish", Toggle.Off, "If on, fish cannot be picked up during winter");
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
public static class PickableTweaks
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(Pickable), "Awake")]
private static class Pickable_Awake_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[UsedImplicitly]
private static void Postfix(Pickable __instance)
{
if (m_enabled.Value != 0 && GetHarvestData(((Object)__instance).name.Replace("(Clone)", string.Empty), out var result))
{
__instance.m_amount = result.Amount;
}
}
}
[HarmonyPatch(typeof(Pickable), "Interact")]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
private static class Pickable_Interact_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[UsedImplicitly]
private static bool Prefix(Pickable __instance)
{
if (m_enabled.Value == Toggle.Off)
{
return true;
}
if (!GetHarvestData(((Object)__instance).name.Replace("(Clone)", string.Empty), out var result))
{
return true;
}
return result.CanHarvest;
}
}
[HarmonyPatch(typeof(Pickable), "GetHoverText")]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
private static class Pickable_GetHoverText_Patch
{
[UsedImplicitly]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(Pickable __instance, ref string __result)
{
if (m_enabled.Value != 0 && GetHarvestData(((Object)__instance).name.Replace("(Clone)", string.Empty), out var result) && !result.CanHarvest)
{
__result += Localization.instance.Localize("\n <color=red>$cannot_pick</color>");
}
}
}
[Serializable]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public class Harvest
{
[Serializable]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
public class HarvestData
{
public int Amount;
public bool CanHarvest;
}
public HarvestData Summer = new HarvestData();
public HarvestData Fall = new HarvestData();
public HarvestData Winter = new HarvestData();
public HarvestData Spring = new HarvestData();
}
private const string FileName = "Pickables.yml";
private static readonly string FilePath;
private static readonly CustomSyncedValue<string> ServerPickableConfigs;
private static ConfigEntry<Toggle> m_enabled;
public static readonly Dictionary<string, Harvest> m_data;
private static readonly ISerializer serializer;
private static readonly IDeserializer deserializer;
public static void Setup()
{
m_enabled = ConfigManager.config("Tweaks", "Pickable Enabled", Toggle.Off, "If on, pickable tweaks are enabled");
Read();
ServerPickableConfigs.ValueChanged += OnServerValueChanged;
if (m_data.Count == 0)
{
TweaksManager.OnZNetScenePrefab += delegate(GameObject prefab)
{
Pickable val = default(Pickable);
if (!m_data.ContainsKey(((Object)prefab).name) && prefab.TryGetComponent<Pickable>(ref val))
{
m_data[((Object)prefab).name] = new Harvest
{
Summer = CreateData(val.m_amount),
Fall = CreateData(val.m_amount),
Winter = CreateData(val.m_amount, canHarvest: false),
Spring = CreateData(val.m_amount)
};
}
};
TweaksManager.OnFinishSetup += Write;
}
TweaksManager.OnZNetAwake += delegate
{
UpdateServerConfigs();
SetupFileWatch();
};
}
private static void OnServerValueChanged()
{
if (!Object.op_Implicit((Object)(object)ZNet.m_instance) || ZNet.m_instance.IsServer() || string.IsNullOrEmpty(ServerPickableConfigs.Value))
{
return;
}
try
{
m_data.Clear();
m_data.AddRange(deserializer.Deserialize<Dictionary<string, Harvest>>(ServerPickableConfigs.Value));
}
catch
{
SeasonalityPlugin.Record.LogWarning("Failed to deserialize server pickable configs");
}
}
public static void SetupFileWatch()
{
FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(TweaksManager.FolderPath, "Pickables.yml");
fileSystemWatcher.Changed += ReadConfigValues;
fileSystemWatcher.Created += ReadConfigValues;
fileSystemWatcher.Renamed += ReadConfigValues;
fileSystemWatcher.IncludeSubdirectories = false;
fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
fileSystemWatcher.EnableRaisingEvents = true;
static void ReadConfigValues(object sender, FileSystemEventArgs args)
{
if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer())
{
Read();
UpdateServerConfigs();
}
}
}
public static void UpdateServerConfigs()
{
if (Object.op_Implicit((Object)(object)ZNet.m_instance) && ZNet.m_instance.IsServer())
{
ServerPickableConfigs.Value = serializer.Serialize((object)m_data);
}
}
private static bool GetHarvestData(string prefabName, out Harvest.HarvestData result)
{
result = new Harvest.HarvestData();
if (!m_data.TryGetValue(prefabName, out var value))
{
return false;
}
switch (Configs.m_season.Value)
{
case Season.Fall:
result = value.Fall;
break;
case Season.Winter:
result = value.Winter;
break;
case Season.Spring:
result = value.Spring;
break;
case Season.Summer:
result = value.Summer;
break;
default:
return false;
}
return true;
}
public static void Read()
{
if (!Directory.Exists(TweaksManager.FolderPath))
{
Directory.CreateDirectory(TweaksManager.FolderPath);
}
if (!File.Exists(FilePath))
{
return;
}
try
{
m_data.Clear();
m_data.AddRange(deserializer.Deserialize<Dictionary<string, Harvest>>(File.ReadAllText(FilePath)));
}
catch
{
SeasonalityPlugin.Record.LogWarning("Failed to deserialize: " + Path.GetFileName(FilePath));
}
}
public static void Write()
{
if (!Directory.Exists(TweaksManager.FolderPath))
{
Directory.CreateDirectory(TweaksManager.FolderPath);
}
string contents = serializer.Serialize((object)m_data);
File.WriteAllText(FilePath, contents);
}
public static Harvest.HarvestData CreateData(int amount, bool canHarvest = true)
{
return new Harvest.HarvestData
{
Amount = amount,
CanHarvest = canHarvest
};
}
static PickableTweaks()
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
string folderPath = TweaksManager.FolderPath;
char directorySeparatorChar = Path.DirectorySeparatorChar;
FilePath = folderPath + directorySeparatorChar + "Pickables.yml";
ServerPickableConfigs = new CustomSyncedValue<string>(ConfigManager.ConfigSync, "ServerPickableConfigs", "");
m_enabled = null;
m_data = new Dictionary<string, Harvest>();
serializer = new SerializerBuilder().Build();
deserializer = new DeserializerBuilder().Build();
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public static class PlantTweaks
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(Plant), "Grow")]
private static class Plant_Grow_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[UsedImplicitly]
private static bool Prefix(Plant __instance)
{
if (m_enabled.Value == Toggle.Off)
{
return true;
}
if (!m_data.TryGetValue(((Object)__instance).name.Replace("(Clone)", string.Empty), out var value))
{
return true;
}
return Configs.m_season.Value switch
{
Season.Spring => value.Spring.CanHarvest,
Season.Summer => value.Summer.CanHarvest,
Season.Fall => value.Fall.CanHarvest,
Season.Winter => value.Winter.CanHarvest,
_ => true,
};
}
}
[HarmonyPatch(typeof(Plant), "GetStatus")]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
private static class Plant_GetStatus_Patch
{
[UsedImplicitly]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(Plant __instance, ref Status __result)
{
if (m_enabled.Value == Toggle.Off || !m_data.TryGetValue(((Object)__instance).name.Replace("(Clone)", string.Empty), out var value))
{
return;
}
switch (Configs.m_season.Value)
{
case Season.Spring:
if (!value.Spring.CanHarvest)
{
__result = (Status)2;
}
break;
case Season.Summer:
if (!value.Summer.CanHarvest)
{
__result = (Status)2;
}
break;
case Season.Fall:
if (!value.Fall.CanHarvest)
{
__result = (Status)2;
}
break;
case Season.Winter:
if (!value.Winter.CanHarvest)
{
__result = (Status)2;
}
break;
}
}
}
[HarmonyPatch(typeof(Plant), "GetHoverText")]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
private static class Plant_GetHoverText_Patch
{
[UsedImplicitly]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(Plant __instance, ref string __result)
{
if (m_enabled.Value == Toggle.Off || !m_data.TryGetValue(((Object)__instance).name.Replace("(Clone)", string.Empty), out var value))
{
return;
}
switch (Configs.m_season.Value)
{
case Season.Spring:
if (value.Spring.CanHarvest)
{
return;
}
break;
case Season.Summer:
if (value.Summer.CanHarvest)
{
return;
}
break;
case Season.Fall:
if (value.Fall.CanHarvest)
{
return;
}
break;
case Season.Winter:
if (value.Winter.CanHarvest)
{
return;
}
break;
}
__result += Localization.instance.Localize("\n <color=red>$" + Configs.m_season.Value.ToString().ToLower() + "_cannot_grow</color>");
}
}
[HarmonyPatch(typeof(Plant), "Awake")]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
private static class Plant_Awake_Patch
{
[UsedImplicitly]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(Plant __instance)
{
if (m_enabled.Value != 0 && m_data.TryGetValue(((Object)__instance).name.Replace("(Clone)", string.Empty), out var value))
{
Plants.Data data;
switch (Configs.m_season.Value)
{
default:
return;
case Season.Spring:
data = value.Spring;
break;
case Season.Summer:
data = value.Summer;
break;
case Season.Fall:
data = value.Fall;
break;
case Season.Winter:
data = value.Winter;
break;
}
__instance.m_maxScale = data.MaxScale;
__instance.m_minScale = data.MinScale;
__instance.m_growTimeMax = data.GrowTimeMax;
__instance.m_growTime = data.GrowTime;
}
}
}
[Serializable]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public class Plants
{
[Serializable]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
public class Data
{
public float MaxScale;
public float MinScale;
public float GrowTimeMax;
public float GrowTime;
public bool CanHarvest;
}
public Data Summer = new Data();
public Data Fall = new Data();
public Data Winter = new Data();
public Data Spring = new Data();
}
private const string FileName = "Plants.yml";
private static readonly string FilePath;
private static readonly CustomSyncedValue<string> ServerConfigs;
private static ConfigEntry<Toggle> m_enabled;
public static readonly Dictionary<string, Plants> m_data;
private static readonly ISerializer serializer;
private static readonly IDeserializer deserializer;
public static void Setup()
{
m_enabled = ConfigManager.config("Tweaks", "Plants Tweaks", Toggle.Off, "If on, plant tweaks are enabled");
Read();
ServerConfigs.ValueChanged += OnServerValueChanged;
if (m_data.Count == 0)
{
TweaksManager.OnZNetScenePrefab += delegate(GameObject prefab)
{
Plant val = default(Plant);
if (!m_data.ContainsKey(((Object)prefab).name) && prefab.TryGetComponent<Plant>(ref val))
{
m_data[((Object)prefab).name] = new Plants
{
Summer = Create(val.m_minScale, val.m_maxScale, val.m_growTimeMax, val.m_growTime),
Fall = Create(val.m_minScale, val.m_maxScale, val.m_growTimeMax, val.m_growTime),
Winter = Create(val.m_minScale, val.m_maxScale, val.m_growTimeMax, val.m_growTime, canHarvest: false),
Spring = Create(val.m_minScale, val.m_maxScale, val.m_growTimeMax, val.m_growTime)
};
}
};
TweaksManager.OnFinishSetup += Write;
}
TweaksManager.OnZNetAwake += delegate
{
UpdateServerConfigs();
SetupFileWatch();
};
}
private static void OnServerValueChanged()
{
if (!Object.op_Implicit((Object)(object)ZNet.m_instance) || ZNet.m_instance.IsServer() || string.IsNullOrEmpty(ServerConfigs.Value))
{
return;
}
try
{
m_data.Clear();
m_data.AddRange(deserializer.Deserialize<Dictionary<string, Plants>>(ServerConfigs.Value));
}
catch
{
SeasonalityPlugin.Record.LogWarning("Failed to deserialize server plant configs");
}
}
public static void UpdateServerConfigs()
{
if (Object.op_Implicit((Object)(object)ZNet.m_instance) && ZNet.m_instance.IsServer())
{
ServerConfigs.Value = serializer.Serialize((object)m_data);
}
}
public static void SetupFileWatch()
{
FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(TweaksManager.FolderPath, "Plants.yml");
fileSystemWatcher.Changed += ReadConfigValues;
fileSystemWatcher.Created += ReadConfigValues;
fileSystemWatcher.Renamed += ReadConfigValues;
fileSystemWatcher.IncludeSubdirectories = false;
fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
fileSystemWatcher.EnableRaisingEvents = true;
static void ReadConfigValues(object sender, FileSystemEventArgs args)
{
if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer())
{
Read();
UpdateServerConfigs();
}
}
}
public static void Write()
{
string contents = serializer.Serialize((object)m_data);
File.WriteAllText(FilePath, contents);
}
public static void Read()
{
if (!File.Exists(FilePath))
{
return;
}
try
{
m_data.Clear();
m_data.AddRange(deserializer.Deserialize<Dictionary<string, Plants>>(File.ReadAllText(FilePath)));
}
catch
{
SeasonalityPlugin.Record.LogWarning("Failed to deserialize plant tweaks: " + Path.GetFileName(FilePath));
}
}
public static Plants.Data Create(float min, float max, float growTimeMax, float growTime, bool canHarvest = true)
{
return new Plants.Data
{
MaxScale = max,
MinScale = min,
GrowTime = growTime,
GrowTimeMax = growTimeMax,
CanHarvest = canHarvest
};
}
static PlantTweaks()
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_005a: Unknown result type (might be due to invalid IL or missing references)
string folderPath = TweaksManager.FolderPath;
char directorySeparatorChar = Path.DirectorySeparatorChar;
FilePath = folderPath + directorySeparatorChar + "Plants.yml";
ServerConfigs = new CustomSyncedValue<string>(ConfigManager.ConfigSync, "ServerPlantConfigs", "");
m_enabled = null;
m_data = new Dictionary<string, Plants>();
serializer = new SerializerBuilder().Build();
deserializer = new DeserializerBuilder().Build();
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public static class SpawnTweaks
{
[HarmonyPatch(typeof(SpawnSystem), "Spawn")]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
private static class SpawnSystem_Spawn_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static bool Prefix(SpawnData critter)
{
if (m_enabled.Value == Toggle.Off)
{
return true;
}
if (!m_data.TryGetValue(((Object)critter.m_prefab).name, out var value))
{
return true;
}
bool value2;
return !value.TryGetValue(Configs.m_season.Value, out value2) || value2;
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(SpawnArea), "SpawnOne")]
private static class SpawnArea_SpawnOne_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static bool Prefix(SpawnArea __instance)
{
if (m_enabled.Value == Toggle.Off)
{
return true;
}
foreach (SpawnData prefab in __instance.m_prefabs)
{
if (prefab != null && !((Object)(object)prefab.m_prefab == (Object)null) && m_data.TryGetValue(((Object)prefab.m_prefab).name, out var value) && value.TryGetValue(Configs.m_season.Value, out var value2) && !value2)
{
return false;
}
}
return true;
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(BaseAI), "UpdateAI")]
private static class BaseAI_UpdateAI_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static bool Prefix(BaseAI __instance, float dt, ref bool __result)
{
if (m_enabled.Value == Toggle.Off)
{
return true;
}
if (!__instance.m_nview.IsValid() || !__instance.m_nview.IsOwner())
{
return true;
}
string prefabName = Utils.GetPrefabName(((Object)__instance).name);
if (!m_data.TryGetValue(prefabName, out var value))
{
return true;
}
if (!value.TryGetValue(Configs.m_season.Value, out var value2))
{
return true;
}
if (value2)
{
return true;
}
__instance.MoveAwayAndDespawn(dt, true);
__result = false;
return false;
}
}
private static readonly string FileName = "SpawnTweaks.yml";
private static readonly string FilePath = Path.Combine(TweaksManager.FolderPath, FileName);
public static readonly Dictionary<string, Dictionary<Season, bool>> m_data = new Dictionary<string, Dictionary<Season, bool>>();
private static ConfigEntry<Toggle> m_enabled = null;
private static readonly ISerializer serializer = new SerializerBuilder().Build();
private static readonly IDeserializer deserializer = new DeserializerBuilder().Build();
private static readonly CustomSyncedValue<string> ServerSpawnData = new CustomSyncedValue<string>(ConfigManager.ConfigSync, "Seasonality.Server.SpawnData", "");
public static void OnServerValueChanged()
{
if (!Object.op_Implicit((Object)(object)ZNet.instance) || ZNet.instance.IsServer() || string.IsNullOrEmpty(ServerSpawnData.Value))
{
return;
}
try
{
m_data.Clear();
m_data.AddRange(deserializer.Deserialize<Dictionary<string, Dictionary<Season, bool>>>(ServerSpawnData.Value));
}
catch
{
SeasonalityPlugin.Record.LogWarning("Failed to parse server spawn data.");
}
}
public static void UpdateServerConfigs()
{
if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer())
{
ServerSpawnData.Value = serializer.Serialize((object)m_data);
}
}
public static void SetupFileWatch()
{
FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(TweaksManager.FolderPath, FileName);
fileSystemWatcher.Changed += ReadConfigValues;
fileSystemWatcher.Created += ReadConfigValues;
fileSystemWatcher.Renamed += ReadConfigValues;
fileSystemWatcher.IncludeSubdirectories = false;
fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
fileSystemWatcher.EnableRaisingEvents = true;
static void ReadConfigValues(object sender, FileSystemEventArgs args)
{
if (Object.op_Implicit((Object)(object)ZNet.instance) && ZNet.instance.IsServer())
{
Read();
UpdateServerConfigs();
}
}
}
public static void Setup()
{
m_enabled = ConfigManager.config("Tweaks", "Spawns Enabled", Toggle.Off, "If on, spawns are modified per season");
Read();
ServerSpawnData.ValueChanged += OnServerValueChanged;
if (m_data.Count == 0)
{
TweaksManager.OnZNetScenePrefab += delegate(GameObject prefab)
{
Character val = default(Character);
if (!m_data.ContainsKey(((Object)prefab).name) && prefab.TryGetComponent<Character>(ref val) && !(val is Player))
{
m_data[((Object)prefab).name] = new Dictionary<Season, bool>
{
[Season.Spring] = true,
[Season.Summer] = true,
[Season.Fall] = true,
[Season.Winter] = true
};
}
};
TweaksManager.OnFinishSetup += Write;
}
TweaksManager.OnZNetAwake += delegate
{
UpdateServerConfigs();
SetupFileWatch();
};
}
public static void Write()
{
string contents = serializer.Serialize((object)m_data);
File.WriteAllText(FilePath, contents);
}
public static void Read()
{
if (!File.Exists(FilePath))
{
return;
}
try
{
m_data.Clear();
m_data.AddRange(deserializer.Deserialize<Dictionary<string, Dictionary<Season, bool>>>(File.ReadAllText(FilePath)));
}
catch
{
SeasonalityPlugin.Record.LogWarning("Failed to deserialize spawn tweaks file: " + Path.GetFileName(FilePath));
}
}
}
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
public static class TraderTweaks
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(Trader), "GetAvailableItems")]
private static class Trader_GetAvailableItems_Patch
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(ref List<TradeItem> __result)
{
if (m_enabled.Value == Toggle.Off)
{
return;
}
foreach (SerializedItems.SeasonalItem item in new SerializedItems(GetConfig().Value).m_items)
{
TradeItem tradeItem = item.GetTradeItem();
if (tradeItem != null)
{
__result.Add(tradeItem);
}
}
}
}
private static ConfigEntry<Toggle> m_enabled = null;
private static ConfigEntry<string> m_summerItems = null;
private static ConfigEntry<string> m_fallItems = null;
private static ConfigEntry<string> m_winterItems = null;
private static ConfigEntry<string> m_springItems = null;
private static readonly List<SerializedItems.SeasonalItem> m_defaultSummerItems = new List<SerializedItems.SeasonalItem>
{
new SerializedItems.SeasonalItem("HelmetMidsummerCrown", 1, 300)
};
private static readonly List<SerializedItems.SeasonalItem> m_defaultFallItems = new List<SerializedItems.SeasonalItem>
{
new SerializedItems.SeasonalItem("HelmetPointyHat", 1, 300)
};
private static readonly List<SerializedItems.SeasonalItem> m_defaultWinterItems = new List<SerializedItems.SeasonalItem>();
private static readonly List<SerializedItems.SeasonalItem> m_defaultSpringItems = new List<SerializedItems.SeasonalItem>();
public static void Setup()
{
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Expected O, but got Unknown
//IL_0085: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Expected O, but got Unknown
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Expected O, but got Unknown
//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Expected O, but got Unknown
m_enabled = ConfigManager.config("Tweaks", "Trader Enabled", Toggle.Off, "If on, trader has extra items for sale depending on season");
m_summerItems = ConfigManager.config("Tweaks", "Summer Items", new SerializedItems(m_defaultSummerItems).ToString(), new ConfigDescription("Set summer items added to trader", (AcceptableValueBase)null, new object[1] { SerializedItems.attributes }));
m_fallItems = ConfigManager.config("Tweaks", "Fall Items", new SerializedItems(m_defaultFallItems).ToString(), new ConfigDescription("Set fall items added to trader", (AcceptableValueBase)null, new object[1] { SerializedItems.attributes }));
m_winterItems = ConfigManager.config("Tweaks", "Winter Items", new SerializedItems(m_defaultWinterItems).ToString(), new ConfigDescription("Set fall items added to trader", (AcceptableValueBase)null, new object[1] { SerializedItems.attributes }));
m_springItems = ConfigManager.config("Tweaks", "Spring Items", new SerializedItems(m_defaultSpringItems).ToString(), new ConfigDescription("Set fall items added to trader", (AcceptableValueBase)null, new object[1] { SerializedItems.attributes }));
}
private static ConfigEntry<string> GetConfig()
{
return (ConfigEntry<string>)(Configs.m_season.Value switch
{
Season.Summer => m_summerItems,
Season.Fall => m_fallItems,
Season.Winter => m_winterItems,
Season.Spring => m_springItems,
_ => m_summerItems,
});
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(0)]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(2)]
public static class TweaksManager
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
[HarmonyPatch(typeof(ZNet), "Awake")]
private static class ZNet_Awake_Patch
{
[UsedImplicitly]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(ZNet __instance)
{
if (__instance.IsServer())
{
TweaksManager.OnZNetAwake?.Invoke();
}
}
}
[HarmonyPatch(typeof(ZNetScene), "Awake")]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(0)]
private static class ZNetScene_Awake_Patch
{
[UsedImplicitly]
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
private static void Postfix(ZNetScene __instance)
{
foreach (GameObject prefab in __instance.m_prefabs)
{
if (!((Object)(object)prefab == (Object)null))
{
TweaksManager.OnZNetScenePrefab?.Invoke(prefab);
}
}
TweaksManager.OnFinishSetup?.Invoke();
}
}
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
private static readonly string ConfigFolder;
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(1)]
public static readonly string FolderPath;
public static event Action OnZNetAwake;
[<e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(new byte[] { 2, 1 })]
[method: <e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(new byte[] { 2, 1 })]
[field: <e20e6f32-22c3-4b84-81bd-a666c1d7c470>Nullable(new byte[] { 2, 1 })]
public static event Action<GameObject> OnZNetScenePrefab;
public static event Action OnFinishSetup;
public static void Setup()
{
if (!Directory.Exists(ConfigFolder))
{
Directory.CreateDirectory(ConfigFolder);
}
if (!Directory.Exists(FolderPath))
{
Directory.CreateDirectory(FolderPath);
}
PickableTweaks.Setup();
PlantTweaks.Setup();
FishTweaks.Setup();
SpawnTweaks.Setup();
TraderTweaks.Setup();
BuildTweaks.Setup();
BeeHiveTweaks.Setup();
WetTweaks.Setup();
}
static TweaksManager()
{
string configPath = Paths.ConfigPath;
char directorySeparatorChar = Path.DirectorySeparatorChar;
ConfigFolder = configPath + directorySeparatorChar + "Seasonality";
string configFolder = ConfigFolder;
directorySeparatorChar = Path.DirectorySeparatorChar;
FolderPath = configFolder + directorySeparatorChar + "Tweaks";
}
}
public static class WetTweaks
{
[HarmonyPatch(typeof(Player), "UpdateEnvStatusEffects")]
public static class Player_UpdateEnvStatusEffects
{
[<3d484f37-b8bf-4db0-963a-5fc4e45f8ce1>NullableContext(1)]
public static void Postfix(Player __instance)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//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_003f: 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_0042: Invalid comparison between Unknown and I4
//IL_0044: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Invalid comparison between Unknown and I4
if (enabled.Value == Toggle.Off || Configs.m_season.Value != Season.Winter || ((Character)__instance).GetSEMan().HaveStatusEffect(SEMan.s_statusEffectFreezing))
{
return;
}
DamageModifiers damageModifiers = ((Character)__instance).GetDamageModifiers((WeakSpot)null);
DamageModifier modifier = ((DamageModifiers)(ref damageModifiers)).GetModifier((DamageType)64);
if (((int)modifier == 1 || modifier - 3 <= 1) ? true : false)
{
