using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
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.Permissions;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Common;
using HarmonyLib;
using Jotunn;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using SimpleJson;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("BronzeAgeChest")]
[assembly: AssemblyDescription("https://thunderstore.io/c/valheim/p/probablykory/BronzeAgeChest/")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyProduct("BronzeAgeChest")]
[assembly: AssemblyCopyright("Copyright probablykory © 2024")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("e3243d22-4307-4008-ba36-9f326008cde5")]
[assembly: AssemblyFileVersion("1.0.8")]
[assembly: AssemblyCompany("probablykory")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.8.0")]
[module: <d3f99811-048d-4877-8cce-f85228c1c50b>RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[<140a1b61-9b0f-45d5-865a-7e7a0d70c359>Embedded]
internal sealed class <140a1b61-9b0f-45d5-865a-7e7a0d70c359>EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[<140a1b61-9b0f-45d5-865a-7e7a0d70c359>Embedded]
[CompilerGenerated]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class <d3f99811-048d-4877-8cce-f85228c1c50b>RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public <d3f99811-048d-4877-8cce-f85228c1c50b>RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace BronzeAgeChest
{
public static class RequirementsEntry
{
public static RequirementConfig[] Deserialize(string reqs)
{
return ((IEnumerable<string>)reqs.Split(new char[1] { ',' })).Select((Func<string, RequirementConfig>)delegate(string r)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: 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)
//IL_0060: Expected O, but got Unknown
string[] array = r.Split(new char[1] { ':' });
int result;
int result2;
return new RequirementConfig
{
Item = array[0],
Amount = ((array.Length <= 1 || !int.TryParse(array[1], out result)) ? 1 : result),
AmountPerLevel = ((array.Length > 2 && int.TryParse(array[2], out result2)) ? result2 : 0),
Recover = true
};
}).ToArray();
}
public static string Serialize(RequirementConfig[] reqs)
{
return string.Join(",", reqs.Select((RequirementConfig r) => (r.AmountPerLevel <= 0) ? $"{r.Item}:{r.Amount}" : $"{r.Item}:{r.Amount}:{r.AmountPerLevel}"));
}
}
internal class Entries
{
private Action<object, EventArgs> _action;
public string Name { get; set; } = string.Empty;
public ConfigEntry<string> Table { get; set; }
public ConfigEntry<int> MinTableLevel { get; set; }
public ConfigEntry<int> Amount { get; set; }
public ConfigEntry<string> Requirements { get; set; }
public static Entries GetFromProps(IPlugin instance, string name, string table, string requirements)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Expected O, but got Unknown
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Expected O, but got Unknown
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00aa: Expected O, but got Unknown
Entries entries = new Entries();
entries.Name = name;
entries.Table = instance.Config(entries.Name, "Table", table, new ConfigDescription("Crafting station needed to construct " + entries.Name + ".", (AcceptableValueBase)(object)CraftingStations.GetAcceptableValueList(), new object[1] { ConfigHelper.GetAdminOnlyFlag() }));
entries.Requirements = instance.Config(entries.Name, "Requirements", requirements, new ConfigDescription("The required items to construct " + entries.Name + ".", (AcceptableValueBase)(object)new AcceptableValueConfigNote("You must use valid spawn item codes."), new object[1] { (object)new ConfigurationManagerAttributes
{
IsAdminOnly = true,
CustomDrawer = SharedDrawers.DrawReqConfigTable()
} }));
return entries;
}
private void OnSettingChanged(object sender, EventArgs e)
{
if (_action != null)
{
_action(sender, e);
}
}
public void AddSettingsChangedHandler(Action<object, EventArgs> action)
{
_action = action;
Table.SettingChanged += OnSettingChanged;
MinTableLevel.SettingChanged += OnSettingChanged;
Amount.SettingChanged += OnSettingChanged;
Requirements.SettingChanged += OnSettingChanged;
}
public void RemoveSettingsChangedHandler()
{
Table.SettingChanged -= OnSettingChanged;
MinTableLevel.SettingChanged -= OnSettingChanged;
Amount.SettingChanged -= OnSettingChanged;
Requirements.SettingChanged -= OnSettingChanged;
_action = null;
}
}
public static class Extensions
{
private static Dictionary<string, CustomPiece> dictPieces;
public static Piece GetPiece(Piece piece)
{
Piece val = null;
foreach (KeyValuePair<string, PieceTable> item in ReflectionHelper.GetPrivateField<Dictionary<string, PieceTable>>((object)PieceManager.Instance, "PieceTableMap"))
{
foreach (GameObject piece2 in item.Value.m_pieces)
{
Piece component = piece2.GetComponent<Piece>();
if (!string.IsNullOrEmpty(((Object)component).name) && ((Object)component).name.Equals(((Object)piece).name))
{
val = component;
break;
}
}
if ((Object)(object)val != (Object)null)
{
break;
}
}
return val;
}
public static bool Update(this CustomPiece piece, PieceConfig newPiece)
{
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Expected O, but got Unknown
//IL_0137: Unknown result type (might be due to invalid IL or missing references)
//IL_0141: Expected O, but got Unknown
if ((Object)(object)ZNetScene.instance != (Object)null)
{
Piece piece2 = GetPiece(piece.Piece);
if ((Object)(object)piece2 == (Object)null)
{
ManualLogSource logger = Get.Plugin.Logger;
object obj;
if (piece == null)
{
obj = null;
}
else
{
Piece piece3 = piece.Piece;
obj = ((piece3 != null) ? ((Object)piece3).name : null);
}
logger.LogError((object)("Error updating piece " + (string?)obj + ", did not find existing piece in available piece tables."));
return false;
}
piece2.m_craftingStation = ZNetScene.instance.GetPrefab(newPiece.CraftingStation).GetComponent<CraftingStation>();
piece2.m_resources = newPiece.GetRequirements();
Requirement[] resources = piece2.m_resources;
foreach (Requirement val in resources)
{
GameObject itemPrefab = ObjectDB.instance.GetItemPrefab(((Object)val.m_resItem).name.Replace("JVLmock_", ""));
if ((Object)(object)itemPrefab != (Object)null)
{
val.m_resItem = itemPrefab.GetComponent<ItemDrop>();
}
}
if (dictPieces == null)
{
Dictionary<string, CustomPiece> privateField = ReflectionHelper.GetPrivateField<Dictionary<string, CustomPiece>>((object)PieceManager.Instance, "Pieces");
if (privateField != null)
{
dictPieces = privateField;
}
}
if (dictPieces != null)
{
dictPieces.Remove(((Object)((Component)piece2).gameObject).name);
dictPieces.Add(((Object)((Component)piece2).gameObject).name, new CustomPiece(((Component)piece2).gameObject, piece.PieceTable, false));
}
return true;
}
PieceManager.Instance.RemovePiece(((Object)piece.PiecePrefab).name);
PieceManager.Instance.AddPiece(new CustomPiece(piece.PiecePrefab, false, newPiece));
return false;
}
}
[BepInPlugin("probablykory.BronzeAgeChest", "BronzeAgeChest", "1.0.8")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
internal class BronzeAgeChest : BaseUnityPlugin, IPlugin
{
public const string PluginAuthor = "probablykory";
public const string PluginName = "BronzeAgeChest";
public const string PluginVersion = "1.0.8";
public const string PluginGUID = "probablykory.BronzeAgeChest";
internal static BronzeAgeChest Instance;
internal AssetBundle assetBundle;
private static ConfigEntry<bool> isDebugEnabled = null;
private CustomPiece bronzeChest;
private const string Name = "$piece_chest_bronze";
private const string PieceTable = "Hammer";
private const string Category = "Furniture";
private static Dictionary<string, string> DefaultEnglishLanguageStrings = new Dictionary<string, string> { { "$piece_chest_bronze", "Rugged Chest" } };
public ManualLogSource Logger { get; private set; } = Logger.CreateLogSource("BronzeAgeChest");
public bool Debug
{
get
{
if (isDebugEnabled == null)
{
return true;
}
return isDebugEnabled.Value;
}
}
public Entries Entry { get; protected set; }
private void Awake()
{
Instance = this;
assetBundle = AssetUtils.LoadAssetBundleFromResources("bronzechest");
isDebugEnabled = this.Config("1 - General", "Debugging Enabled", value: false, "If on, mod will output alot more information in the debug log level.");
InitializeFeatures();
AddDefaultLocalizations();
PrefabManager.OnVanillaPrefabsAvailable += OnVanillaPrefabsAvailable;
LocalizationManager.OnLocalizationAdded += OnLocalizationAdded;
SynchronizationManager.OnConfigurationSynchronized += OnConfigurationSynchronized;
((BaseUnityPlugin)this).Config.ConfigReloaded += OnConfigReloaded;
new ConfigWatcher(this);
}
private void InitializeFeatures()
{
Entry = Entries.GetFromProps(Instance, "BronzeChest", "Workbench", "Wood:15,Bronze:1,BronzeNails:10");
}
private void UpdateFeatures()
{
bronzeChest.Update(getPieceFromEntry(Entry));
}
private void OnVanillaPrefabsAvailable()
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Expected O, but got Unknown
this.LogDebugOnly("Vanilla Prefabs Available received.");
bronzeChest = new CustomPiece(assetBundle, "piece_chest_bronze", true, getPieceFromEntry(Entry));
PieceManager.Instance.AddPiece(bronzeChest);
PrefabManager.OnVanillaPrefabsAvailable -= OnVanillaPrefabsAvailable;
}
private void OnConfigReloaded(object sender, EventArgs e)
{
UpdateFeatures();
}
private void OnConfigurationSynchronized(object sender, ConfigurationSynchronizationEventArgs e)
{
UpdateFeatures();
}
private PieceConfig getPieceFromEntry(Entries entry)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: 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_0026: Unknown result type (might be due to invalid IL or missing references)
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0053: Expected O, but got Unknown
return new PieceConfig
{
Name = "$piece_chest_bronze",
CraftingStation = CraftingStations.GetInternalName(entry.Table.Value),
PieceTable = "Hammer",
Category = "Furniture",
Requirements = RequirementsEntry.Deserialize(entry.Requirements.Value)
};
}
private void AddDefaultLocalizations()
{
this.LogDebugOnly("AddLocalizations called.");
CustomLocalization localization = LocalizationManager.Instance.GetLocalization();
string text = "English";
localization.AddTranslation(ref text, DefaultEnglishLanguageStrings);
}
private void OnLocalizationAdded()
{
this.LogDebugOnly("Localization Added received.");
string location = ((object)Instance).GetType().Assembly.Location;
char directorySeparatorChar = Path.DirectorySeparatorChar;
string text = location.Replace(directorySeparatorChar + "BronzeAgeChest.dll", "");
if (Paths.PluginPath.Equals(text))
{
text = Utility.CombinePaths(new string[2]
{
Paths.PluginPath,
"BronzeAgeChest"
});
}
string text2 = Utility.CombinePaths(new string[4] { text, "Translations", "English", "english.json" });
string directoryName = Path.GetDirectoryName(text2);
if (!Directory.Exists(directoryName) || !File.Exists(text2))
{
Directory.CreateDirectory(directoryName);
string contents = SimpleJson.SerializeObject((object)DefaultEnglishLanguageStrings);
File.WriteAllText(text2, contents);
this.LogInfo("Default localizations written to " + text2);
}
LocalizationManager.OnLocalizationAdded -= OnLocalizationAdded;
}
ConfigFile IPlugin.get_Config()
{
return ((BaseUnityPlugin)this).Config;
}
}
}
namespace Microsoft.CodeAnalysis
{
[Microsoft.CodeAnalysis.Embedded]
[CompilerGenerated]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
[CompilerGenerated]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace Common
{
internal class AcceptableValueConfigNote : AcceptableValueBase
{
public virtual string Note { get; }
public AcceptableValueConfigNote(string note)
: base(typeof(string))
{
if (string.IsNullOrEmpty(note))
{
throw new ArgumentException("A string with atleast 1 character is needed", "Note");
}
Note = note;
}
public override object Clamp(object value)
{
return value;
}
public override bool IsValid(object value)
{
return !string.IsNullOrEmpty(value as string);
}
public override string ToDescriptionString()
{
return "# Note: " + Note;
}
}
internal static class ConfigHelper
{
public static ConfigurationManagerAttributes GetAdminOnlyFlag()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
return new ConfigurationManagerAttributes
{
IsAdminOnly = true
};
}
public static ConfigurationManagerAttributes GetTags(Action<ConfigEntryBase> action)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0005: Unknown result type (might be due to invalid IL or missing references)
//IL_000d: Expected O, but got Unknown
return new ConfigurationManagerAttributes
{
CustomDrawer = action
};
}
public static ConfigurationManagerAttributes GetTags()
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Expected O, but got Unknown
return new ConfigurationManagerAttributes();
}
public static ConfigEntry<T> Config<T>(this IPlugin instance, string group, string name, T value, ConfigDescription description)
{
return instance.Config.Bind<T>(group, name, value, description);
}
public static ConfigEntry<T> Config<T>(this IPlugin instance, string group, string name, T value, string description)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
return instance.Config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, new object[1] { GetAdminOnlyFlag() }));
}
}
internal static class RequirementsEntry
{
public static RequirementConfig[] Deserialize(string reqs)
{
return ((IEnumerable<string>)reqs.Split(new char[1] { ',' })).Select((Func<string, RequirementConfig>)delegate(string r)
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: 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)
//IL_0060: Expected O, but got Unknown
string[] array = r.Split(new char[1] { ':' });
int result;
int result2;
return new RequirementConfig
{
Item = array[0],
Amount = ((array.Length <= 1 || !int.TryParse(array[1], out result)) ? 1 : result),
AmountPerLevel = ((array.Length > 2 && int.TryParse(array[2], out result2)) ? result2 : 0),
Recover = true
};
}).ToArray();
}
public static string Serialize(RequirementConfig[] reqs)
{
return string.Join(",", reqs.Select((RequirementConfig r) => (r.AmountPerLevel <= 0) ? $"{r.Item}:{r.Amount}" : $"{r.Item}:{r.Amount}:{r.AmountPerLevel}"));
}
}
internal static class SharedDrawers
{
private static BaseUnityPlugin configManager;
private static BaseUnityPlugin GetConfigManager()
{
if ((Object)(object)configManager == (Object)null && Chainloader.PluginInfos.TryGetValue("com.bepis.bepinex.configurationmanager", out var value) && Object.op_Implicit((Object)(object)value.Instance))
{
configManager = value.Instance;
}
return configManager;
}
public static int GetRightColumnWidth()
{
int result = 130;
BaseUnityPlugin val = GetConfigManager();
if ((Object)(object)val != (Object)null)
{
PropertyInfo propertyInfo = ((object)val)?.GetType().GetProperty("RightColumnWidth", BindingFlags.Instance | BindingFlags.NonPublic);
if (propertyInfo != null)
{
result = (int)propertyInfo.GetValue(val);
}
}
return result;
}
public static void ReloadConfigDisplay()
{
BaseUnityPlugin val = GetConfigManager();
if ((Object)(object)val != (Object)null)
{
object obj = ((object)val).GetType()?.GetProperty("DisplayingWindow")?.GetValue(val);
if (obj is bool && (bool)obj)
{
((object)val).GetType().GetMethod("BuildSettingList").Invoke(val, Array.Empty<object>());
}
}
}
public static Action<ConfigEntryBase> DrawReqConfigTable(bool hasUpgrades = false)
{
return delegate(ConfigEntryBase cfg)
{
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_008d: Expected O, but got Unknown
//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00ee: Expected O, but got Unknown
//IL_0163: Unknown result type (might be due to invalid IL or missing references)
//IL_0168: Unknown result type (might be due to invalid IL or missing references)
//IL_017d: Expected O, but got Unknown
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_012a: Unknown result type (might be due to invalid IL or missing references)
//IL_013f: Expected O, but got Unknown
//IL_0184: Unknown result type (might be due to invalid IL or missing references)
//IL_0189: Unknown result type (might be due to invalid IL or missing references)
//IL_0191: 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_01a6: Expected O, but got Unknown
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
//IL_01cf: Expected O, but got Unknown
//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
//IL_01f0: Expected O, but got Unknown
List<RequirementConfig> list = new List<RequirementConfig>();
bool flag = false;
int rightColumnWidth = GetRightColumnWidth();
GUILayout.BeginVertical(Array.Empty<GUILayoutOption>());
foreach (RequirementConfig item in RequirementsEntry.Deserialize((string)cfg.BoxedValue).ToList())
{
GUILayout.BeginHorizontal(Array.Empty<GUILayoutOption>());
string text = GUILayout.TextField(item.Item, new GUIStyle(GUI.skin.textField)
{
fixedWidth = rightColumnWidth - 33 - (hasUpgrades ? 37 : 0) - 21 - 21 - 12
}, Array.Empty<GUILayoutOption>());
string text2 = (string.IsNullOrEmpty(text) ? item.Item : text);
flag = flag || text2 != item.Item;
int num = item.Amount;
if (int.TryParse(GUILayout.TextField(num.ToString(), new GUIStyle(GUI.skin.textField)
{
fixedWidth = 33f
}, Array.Empty<GUILayoutOption>()), out var result) && result != num)
{
num = result;
flag = true;
}
int num2 = item.AmountPerLevel;
if (hasUpgrades && int.TryParse(GUILayout.TextField(num2.ToString(), new GUIStyle(GUI.skin.textField)
{
fixedWidth = 33f
}, Array.Empty<GUILayoutOption>()), out var result2) && result2 != num2)
{
num2 = result2;
flag = true;
}
if (GUILayout.Button("x", new GUIStyle(GUI.skin.button)
{
fixedWidth = 21f
}, Array.Empty<GUILayoutOption>()))
{
flag = true;
}
else
{
list.Add(new RequirementConfig
{
Item = text2,
Amount = num,
AmountPerLevel = num2
});
}
if (GUILayout.Button("+", new GUIStyle(GUI.skin.button)
{
fixedWidth = 21f
}, Array.Empty<GUILayoutOption>()))
{
flag = true;
list.Add(new RequirementConfig
{
Item = "<Prefab Name>",
Amount = 1
});
}
GUILayout.EndHorizontal();
}
GUILayout.EndVertical();
if (flag)
{
cfg.BoxedValue = RequirementsEntry.Serialize(list.ToArray());
}
};
}
}
internal class ConfigWatcher
{
private BaseUnityPlugin configurationManager;
private IPlugin plugin;
public ConfigWatcher(IPlugin plugin)
{
if (plugin == null)
{
throw new ArgumentNullException("plugin");
}
this.plugin = plugin;
CheckForConfigManager();
}
private void InitializeWatcher()
{
string fileName = Path.GetFileName(plugin.Config.ConfigFilePath);
new Watcher(Path.GetDirectoryName(plugin.Config.ConfigFilePath), fileName).FileChanged += OnFileChanged;
Get.Plugin.LogDebugOnly("File system watcher initialized.");
}
private void CheckForConfigManager()
{
PluginInfo value;
if (GUIManager.IsHeadless())
{
InitializeWatcher();
}
else if (Chainloader.PluginInfos.TryGetValue("com.bepis.bepinex.configurationmanager", out value) && Object.op_Implicit((Object)(object)value.Instance))
{
configurationManager = value.Instance;
Get.Plugin.LogDebugOnly("Configuration manager found, hooking DisplayingWindowChanged");
EventInfo @event = ((object)configurationManager).GetType().GetEvent("DisplayingWindowChanged");
if (@event != null)
{
Action<object, object> action = OnConfigManagerDisplayingWindowChanged;
Delegate handler = Delegate.CreateDelegate(@event.EventHandlerType, action.Target, action.Method);
@event.AddEventHandler(configurationManager, handler);
}
}
else
{
InitializeWatcher();
}
}
private void OnFileChanged(object sender, FileSystemEventArgs e)
{
string configFilePath = plugin.Config.ConfigFilePath;
if (!File.Exists(configFilePath))
{
return;
}
try
{
plugin.Config.SaveOnConfigSet = false;
plugin.Config.Reload();
plugin.Config.SaveOnConfigSet = true;
}
catch
{
Get.Plugin.LogError("There was an issue with your " + Path.GetFileName(configFilePath) + " file.");
Get.Plugin.LogError("Please check the format and spelling.");
}
}
private void OnConfigManagerDisplayingWindowChanged(object sender, object e)
{
if (!(bool)((object)configurationManager).GetType().GetProperty("DisplayingWindow").GetValue(configurationManager, null))
{
plugin.Config.SaveOnConfigSet = false;
plugin.Config.Reload();
plugin.Config.SaveOnConfigSet = true;
}
}
}
internal class CustomSyncedValueBase
{
private class Patches
{
[HarmonyPatch(typeof(ZNet), "Shutdown")]
[HarmonyPostfix]
private static void ZNet_Shutdown()
{
if (ZNetExtension.IsClientInstance(ZNet.instance))
{
foreach (CustomSyncedValueBase syncedValue in SyncedValues)
{
syncedValue.OnResetFromServer();
}
return;
}
foreach (CustomSyncedValueBase syncedValue2 in SyncedValues)
{
syncedValue2.OnServerShutdown();
}
}
}
public readonly string Name;
public readonly Type Type;
private object? boxedValue;
public object? LocalBaseValue;
private CustomRPC customRPC;
private static readonly HashSet<CustomSyncedValueBase> SyncedValues = new HashSet<CustomSyncedValueBase>();
private static Harmony harmony = null;
public bool IsSourceOfTruth { get; private set; } = true;
public object? BoxedValue
{
get
{
return boxedValue;
}
set
{
boxedValue = value;
this.ValueChanged?.Invoke(this, value);
}
}
public event Action<object, object>? ValueChanged;
protected CustomSyncedValueBase(string name, Type type, object? initialValue)
{
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Expected O, but got Unknown
//IL_00af: Expected O, but got Unknown
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0052: Expected O, but got Unknown
Name = name;
Type = type;
SyncedValues.Add(this);
if (harmony == null)
{
harmony = (Harmony)AccessTools.Field(typeof(Main), "Harmony").GetValue(null);
harmony.PatchAll(typeof(Patches));
Get.Plugin.LogDebugOnly("Jotunn's harmony instance obtained, CustomSyncedValueBase+Patches applied.");
}
boxedValue = initialValue;
customRPC = NetworkManager.Instance.AddRPC(Name + "_CustomSyncedValue_RPC", new CoroutineHandler(OnServerReceive), new CoroutineHandler(OnClientReceive));
SynchronizationManager.Instance.AddInitialSynchronization(customRPC, (Func<ZPackage>)GetPackage);
}
public void SendPackage()
{
if ((Object)(object)ZNet.instance == (Object)null)
{
Get.Plugin.LogDebugOnly("SendPackage called but am not connected.");
}
if (!SynchronizationManager.Instance.PlayerIsAdmin)
{
Get.Plugin.LogDebugOnly("SendPackage called but Player is not admin.");
}
if ((Object)(object)ZNet.instance != (Object)null && SynchronizationManager.Instance.PlayerIsAdmin)
{
ZPackage package = GetPackage();
if (ZNetExtension.IsClientInstance(ZNet.instance))
{
customRPC.SendPackage(ZRoutedRpc.instance.GetServerPeerID(), package);
}
else
{
customRPC.SendPackage(ZNet.instance.m_peers, package);
}
}
}
private ZPackage GetPackage()
{
return new PackageEntry
{
key = Name,
type = Type,
value = boxedValue
}.ToPackage();
}
private IEnumerator OnServerReceive(long sender, ZPackage package)
{
Get.Plugin.LogDebugOnly($"Server received RPC: {sender} {package}");
yield return null;
ParsedEntries parsedEntries = package.ReadEntries();
if (parsedEntries.Count > 0 && parsedEntries.TryGetValue(Name, out var value))
{
BoxedValue = (LocalBaseValue = value.value);
Get.Plugin.LogDebugOnly($"Set local and boxed: {value.value}");
customRPC.SendPackage(ZNet.instance.m_peers.Where((ZNetPeer x) => x.m_uid != sender).ToList(), package);
}
else
{
OnReceiveError(parsedEntries);
}
}
private IEnumerator OnClientReceive(long sender, ZPackage package)
{
Get.Plugin.LogDebugOnly($"Client received RPC: {sender} {package}");
yield return null;
ParsedEntries parsedEntries = package.ReadEntries();
if (parsedEntries.Count > 0 && parsedEntries.TryGetValue(Name, out var value))
{
IsSourceOfTruth = false;
if (LocalBaseValue == null)
{
LocalBaseValue = BoxedValue;
}
BoxedValue = value.value;
Get.Plugin.LogDebugOnly($"Set source of truth: {IsSourceOfTruth}, {Environment.NewLine}local: {LocalBaseValue} {Environment.NewLine}boxed: {BoxedValue}");
}
else
{
OnReceiveError(parsedEntries);
}
}
private void OnReceiveError(ParsedEntries entries)
{
Get.Plugin.LogWarning(Name + "_CustomSyncedValue_RPC recieved package without expected key: " + Name);
string text = "";
foreach (KeyValuePair<string, PackageEntry> entry in entries)
{
text += $"{entry.Key} - {entry.Value.type} - {entry.Value.value?.ToString()} {Environment.NewLine}";
}
Get.Plugin.LogWarning("Result: " + Environment.NewLine + text);
}
private void OnResetFromServer()
{
BoxedValue = LocalBaseValue;
IsSourceOfTruth = true;
LocalBaseValue = null;
}
private void OnServerShutdown()
{
}
}
internal sealed class CustomSyncedValue<T> : CustomSyncedValueBase
{
public T Value
{
get
{
return (T)base.BoxedValue;
}
set
{
base.BoxedValue = value;
if (base.BoxedValue != null)
{
SendPackage();
}
}
}
public CustomSyncedValue(string name, T value = default(T))
: base(name, typeof(T), value)
{
}
public void AssignLocalValue(T value)
{
if (base.IsSourceOfTruth && SynchronizationManager.Instance.PlayerIsAdmin)
{
Value = value;
}
else
{
LocalBaseValue = value;
}
}
}
internal class ParsedEntries : Dictionary<string, PackageEntry>
{
}
internal class PackageEntry
{
public string key;
public Type type;
public object? value;
}
internal class InvalidDeserializationTypeException : Exception
{
public string expected;
public string received;
public string field = "";
}
internal static class PackageUtils
{
public static string GetPackageTypeString(Type type)
{
return type.AssemblyQualifiedName;
}
public static void AddValue(this ZPackage package, object? value)
{
Type type = value?.GetType();
if (value is Enum)
{
value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
}
else
{
if (value is ICollection collection)
{
package.Write(collection.Count);
{
foreach (object item in collection)
{
package.AddValue(item);
}
return;
}
}
if ((object)type != null && type.IsValueType && !type.IsPrimitive)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
package.Write(fields.Length);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
package.Write(GetPackageTypeString(fieldInfo.FieldType));
package.AddValue(fieldInfo.GetValue(value));
}
return;
}
}
ZRpc.Serialize(new object[1] { value }, ref package);
}
public static void AddEntry(this ZPackage package, PackageEntry entry)
{
package.Write(entry.key);
package.Write((entry.value == null) ? "" : GetPackageTypeString(entry.type));
package.AddValue(entry.value);
}
public static ZPackage ToPackage(this PackageEntry packageEntry)
{
return new List<PackageEntry> { packageEntry }.ToPackage();
}
public static ZPackage ToPackage(this IEnumerable<PackageEntry> packageEntries)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Expected O, but got Unknown
ZPackage val = new ZPackage();
val.Write(packageEntries?.Count() ?? 0);
foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
{
val.AddEntry(item);
}
return val;
}
public static object ReadValueWithType(this ZPackage package, Type type)
{
if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
{
FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
int num = package.ReadInt();
if (num != fields.Length)
{
throw new InvalidDeserializationTypeException
{
received = $"(field count: {num})",
expected = $"(field count: {fields.Length})"
};
}
object uninitializedObject = FormatterServices.GetUninitializedObject(type);
FieldInfo[] array = fields;
foreach (FieldInfo fieldInfo in array)
{
string text = package.ReadString();
if (text != GetPackageTypeString(fieldInfo.FieldType))
{
throw new InvalidDeserializationTypeException
{
received = text,
expected = GetPackageTypeString(fieldInfo.FieldType),
field = fieldInfo.Name
};
}
fieldInfo.SetValue(uninitializedObject, package.ReadValueWithType(fieldInfo.FieldType));
}
return uninitializedObject;
}
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
{
int num2 = package.ReadInt();
IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
for (int j = 0; j < num2; j++)
{
object obj = package.ReadValueWithType(type2);
dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
}
return dictionary;
}
if (type != typeof(List<string>) && type.IsGenericType)
{
Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
if ((object)type3 != null && type3.IsAssignableFrom(type))
{
int num3 = package.ReadInt();
object obj2 = Activator.CreateInstance(type);
MethodInfo method = type3.GetMethod("Add");
for (int k = 0; k < num3; k++)
{
method.Invoke(obj2, new object[1] { package.ReadValueWithType(type.GenericTypeArguments[0]) });
}
return obj2;
}
}
ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
List<object> source = new List<object>();
ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
return source.FirstOrDefault();
}
public static ParsedEntries ReadEntries(this ZPackage package)
{
ParsedEntries parsedEntries = new ParsedEntries();
int num = package.ReadInt();
for (int i = 0; i < num; i++)
{
string key = package.ReadString();
string text = package.ReadString();
Type type = Type.GetType(text);
if (text == "" || type != null)
{
object obj;
try
{
obj = ((text == "") ? null : package.ReadValueWithType(type));
}
catch (InvalidDeserializationTypeException ex)
{
Get.Plugin.LogWarning("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text);
continue;
}
if (obj != null)
{
parsedEntries[key] = new PackageEntry
{
key = key,
type = type,
value = obj
};
}
continue;
}
Get.Plugin.LogWarning("Got invalid type " + text + ", abort reading of received configs");
return new ParsedEntries();
}
return parsedEntries;
}
public static void Test()
{
}
}
internal interface IPlugin
{
ConfigFile Config { get; }
bool Debug { get; }
ManualLogSource Logger { get; }
}
internal static class LoggingExtensions
{
private static readonly Dictionary<string, ManualLogSource> logSources = new Dictionary<string, ManualLogSource>();
internal static ManualLogSource GetLogger(this IPlugin mod)
{
if (mod.Debug)
{
Type declaringType = new StackFrame(2).GetMethod().DeclaringType;
if (!logSources.TryGetValue(declaringType.FullName, out var value))
{
value = Logger.CreateLogSource(declaringType.FullName);
logSources.Add(declaringType.FullName, value);
}
return value;
}
return mod.Logger;
}
public static void LogDebugOnly(this IPlugin mod, object data)
{
if (mod.Debug)
{
mod.GetLogger().LogDebug(data);
}
}
public static void LogDebug(this IPlugin mod, object data)
{
if (mod.Debug)
{
mod.GetLogger().LogDebug(data);
}
else
{
mod.Logger.LogDebug(data);
}
}
public static void LogInfo(this IPlugin mod, object data)
{
if (mod.Debug)
{
mod.GetLogger().LogInfo(data);
}
else
{
mod.Logger.LogInfo(data);
}
}
public static void LogMessage(this IPlugin mod, object data)
{
if (mod.Debug)
{
mod.GetLogger().LogMessage(data);
}
else
{
mod.Logger.LogMessage(data);
}
}
public static void LogWarning(this IPlugin mod, object data)
{
if (mod.Debug)
{
mod.GetLogger().LogWarning(data);
}
else
{
mod.Logger.LogWarning(data);
}
}
public static void LogError(this IPlugin mod, object data)
{
if (mod.Debug)
{
mod.GetLogger().LogError(data);
}
else
{
mod.Logger.LogError(data);
}
}
public static void LogFatal(this IPlugin mod, object data)
{
if (mod.Debug)
{
mod.GetLogger().LogFatal(data);
}
else
{
mod.Logger.LogFatal(data);
}
}
}
internal static class Get
{
private static IPlugin cachedModRef;
public static IPlugin Plugin
{
get
{
if (cachedModRef == null)
{
cachedModRef = AccessTools.Field((from p in new StackFrame(0).GetMethod().DeclaringType.Assembly.GetTypes()
where typeof(IPlugin).IsAssignableFrom(p)
select p).FirstOrDefault(), "Instance").GetValue(null) as IPlugin;
cachedModRef.LogDebugOnly("Caching static mod reference");
}
return cachedModRef;
}
}
}
internal class Watcher
{
private FileSystemWatcher fileSystemWatcher;
public bool EnableRaisingEvents
{
get
{
if (fileSystemWatcher != null)
{
return fileSystemWatcher.EnableRaisingEvents;
}
return false;
}
set
{
if (fileSystemWatcher != null)
{
fileSystemWatcher.EnableRaisingEvents = value;
}
}
}
public event Action<object, FileSystemEventArgs>? FileChanged;
public Watcher(string path, string filter)
{
if (path == null)
{
throw new ArgumentNullException("path");
}
if (filter == null)
{
throw new ArgumentNullException("filter");
}
Get.Plugin.LogDebugOnly("Watcher created for " + path + ", " + filter);
fileSystemWatcher = new FileSystemWatcher(path, filter);
fileSystemWatcher.Changed += OnCreatedChangedOrRenamed;
fileSystemWatcher.Created += OnCreatedChangedOrRenamed;
fileSystemWatcher.Renamed += OnCreatedChangedOrRenamed;
fileSystemWatcher.IncludeSubdirectories = true;
fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
fileSystemWatcher.EnableRaisingEvents = true;
}
private void OnCreatedChangedOrRenamed(object sender, FileSystemEventArgs args)
{
Get.Plugin.LogDebugOnly($"OnCreatedChangedOrRenamed triggered {args.Name}, {args.ChangeType}");
this.FileChanged?.Invoke(sender, args);
}
}
}
