using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using UnityEngine;
using Zio;
using Zio.FileSystems;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("ZioConfigFile")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+989b526372e295d2a3d8d6eff4aa3222af20bb5c")]
[assembly: AssemblyProduct("ZioConfigFile")]
[assembly: AssemblyTitle("ZioConfigFile")]
[assembly: AssemblyVersion("1.0.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace ZioConfigFile
{
public class ZioConfigEntry<T> : ZioConfigEntryBase
{
private T _typedValue;
public T Value
{
get
{
return _typedValue;
}
set
{
value = ClampValue(value);
if (!value.Equals(_typedValue))
{
T typedValue = _typedValue;
_typedValue = value;
OnSettingChanged(this, typedValue);
}
}
}
public override object BoxedValue
{
get
{
return Value;
}
set
{
Value = (T)value;
}
}
public ZioConfigEntry(ConfigDefinition configDefinition, T defaultValue, ConfigDescription configDescription)
: base(configDefinition, typeof(T), defaultValue, configDescription)
{
}
public static implicit operator ConfigEntry<T>(ZioConfigEntry<T> zioEntry)
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected O, but got Unknown
if (zioEntry.configEntryFallback != null)
{
return (ConfigEntry<T>)(object)zioEntry.configEntryFallback;
}
if (ZioConfigEntryBase.fallbackConfigFile == null)
{
ZioConfigEntryBase.fallbackConfigFile = new ConfigFile("", false)
{
SaveOnConfigSet = false
};
}
ConfigEntry<T> fallback = new ConfigEntry<T>(ZioConfigEntryBase.fallbackConfigFile, zioEntry.Definition, (T)zioEntry.DefaultValue, zioEntry.Description);
fallback.SettingChanged += delegate
{
if (!zioEntry.duckChanged)
{
zioEntry.duckFallbackChanged = true;
zioEntry.Value = fallback.Value;
zioEntry.duckFallbackChanged = false;
}
};
zioEntry.SettingChanged += delegate
{
if (!zioEntry.duckFallbackChanged)
{
zioEntry.duckChanged = true;
fallback.Value = zioEntry.Value;
zioEntry.duckChanged = false;
}
};
zioEntry.configEntryFallback = (ConfigEntryBase)(object)fallback;
return (ConfigEntry<T>)(object)zioEntry.configEntryFallback;
}
}
public abstract class ZioConfigEntryBase
{
public bool DontSaveOnChange;
protected ConfigEntryBase configEntryFallback;
protected bool duckChanged;
protected bool duckFallbackChanged;
protected static ConfigFile fallbackConfigFile;
public ConfigDefinition Definition { get; }
public ConfigDescription Description { get; }
public Type SettingType { get; }
public object DefaultValue { get; }
public abstract object BoxedValue { get; set; }
public event Action<ZioConfigEntryBase, object, bool> SettingChanged;
protected ZioConfigEntryBase(ConfigDefinition configDefinition, Type settingType, object defaultValue, ConfigDescription configDescription)
{
Definition = configDefinition ?? throw new ArgumentNullException("configDefinition");
SettingType = settingType ?? throw new ArgumentNullException("settingType");
Description = configDescription ?? ConfigDescription.Empty;
if (Description.AcceptableValues != null && !SettingType.IsAssignableFrom(Description.AcceptableValues.ValueType))
{
throw new AggregateException("configDescription.AcceptableValues is for a different type than the type of this setting");
}
DefaultValue = defaultValue;
BoxedValue = defaultValue;
}
public string GetSerializedValue()
{
return TomlTypeConverter.ConvertToString(BoxedValue, SettingType);
}
public void SetSerializedValue(string value)
{
try
{
BoxedValue = TomlTypeConverter.ConvertToValue(value, SettingType);
}
catch (Exception ex)
{
ZioConfigFile.Logger.LogWarning((object)$"Config value of setting \"{Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
}
}
public T ClampValue<T>(T value)
{
return (Description.AcceptableValues != null) ? ((T)Description.AcceptableValues.Clamp((object)value)) : value;
}
public void OnSettingChanged(ZioConfigEntryBase config, object oldValue)
{
this.SettingChanged?.Invoke(config, oldValue, DontSaveOnChange);
}
public void WriteDescription(StreamWriter writer)
{
if (!string.IsNullOrEmpty(Description.Description))
{
writer.WriteLine("## " + Description.Description.Replace("\n", "\n## "));
}
writer.WriteLine("# Setting type: " + SettingType.Name);
writer.WriteLine("# Default value: " + TomlTypeConverter.ConvertToString(DefaultValue, SettingType));
if (Description.AcceptableValues != null)
{
writer.WriteLine(Description.AcceptableValues.ToDescriptionString());
}
else if (SettingType.IsEnum)
{
writer.WriteLine("# Acceptable values: " + string.Join(", ", Enum.GetNames(SettingType)));
if (SettingType.GetCustomAttributes(typeof(FlagsAttribute), inherit: true).Any())
{
writer.WriteLine("# Multiple values can be set at the same time by separating them with , (e.g. Debug, Warning)");
}
}
}
}
public class ZioConfigFile : IDictionary<ConfigDefinition, ZioConfigEntryBase>, ICollection<KeyValuePair<ConfigDefinition, ZioConfigEntryBase>>, IEnumerable<KeyValuePair<ConfigDefinition, ZioConfigEntryBase>>, IEnumerable
{
protected object _ioLock = new object();
private static readonly FileSystem InternalFileSystem = (FileSystem)new PhysicalFileSystem();
private readonly Stopwatch saveStopwatch = new Stopwatch();
private bool _waitingForSaves;
public int waitDuration = 1000;
public BepInPlugin OwnerMetadata { get; }
public FileSystem FileSystem { get; }
public UPath FilePath { get; }
public Dictionary<ConfigDefinition, ZioConfigEntryBase> Entries { get; } = new Dictionary<ConfigDefinition, ZioConfigEntryBase>();
protected Dictionary<ConfigDefinition, string> OrphanedEntries { get; } = new Dictionary<ConfigDefinition, string>();
public static ManualLogSource Logger { get; } = new ManualLogSource("ZioConfigFile");
public static FileSystem BepinConfigFileSystem { get; } = (FileSystem)new SubFileSystem((IFileSystem)(object)InternalFileSystem, InternalFileSystem.ConvertPathFromInternal(Paths.ConfigPath), true);
public bool SaveOnConfigSet { get; set; } = true;
public int Count
{
get
{
lock (_ioLock)
{
return Entries.Count;
}
}
}
public bool IsReadOnly => false;
ZioConfigEntryBase IDictionary<ConfigDefinition, ZioConfigEntryBase>.this[ConfigDefinition key]
{
get
{
lock (_ioLock)
{
return Entries[key];
}
}
set
{
throw new InvalidOperationException("Directly setting a config entry is not supported");
}
}
public ZioConfigEntryBase this[ConfigDefinition key]
{
get
{
lock (_ioLock)
{
return Entries[key];
}
}
}
public ZioConfigEntryBase this[string section, string key] => this[new ConfigDefinition(section, key)];
public ICollection<ConfigDefinition> Keys
{
get
{
lock (_ioLock)
{
return Entries.Keys;
}
}
}
ICollection<ZioConfigEntryBase> IDictionary<ConfigDefinition, ZioConfigEntryBase>.Values
{
get
{
lock (_ioLock)
{
return Entries.Values;
}
}
}
public event Action ConfigReloaded;
public event Action<ZioConfigEntryBase, object> SettingChanged;
public ZioConfigFile(BepInPlugin plugin, bool saveOnInit = true)
: this(BepinConfigFileSystem, UPath.op_Implicit(plugin.Name), saveOnInit, plugin)
{
}//IL_000c: Unknown result type (might be due to invalid IL or missing references)
public ZioConfigFile(FileSystem fileSystem, UPath path, bool saveOnInit, BaseUnityPlugin unityPlugin)
: this(fileSystem, path, saveOnInit, unityPlugin.Info.Metadata)
{
}//IL_0002: Unknown result type (might be due to invalid IL or missing references)
public ZioConfigFile(FileSystem fileSystem, UPath path, bool saveOnInit, BepInPlugin bepInPlugin = null)
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
OwnerMetadata = bepInPlugin;
FileSystem = fileSystem;
FilePath = path;
if (fileSystem.FileExists(path))
{
Reload();
}
else if (saveOnInit)
{
Save();
}
}
public void Reload()
{
InternalReload();
}
protected virtual void InternalReload()
{
//IL_001b: 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_0105: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Expected O, but got Unknown
lock (_ioLock)
{
if (!FileSystem.FileExists(FilePath))
{
return;
}
OrphanedEntries.Clear();
using Stream stream = FileSystem.OpenFile(FilePath, FileMode.Open, FileAccess.Read, FileShare.None);
using StreamReader streamReader = new StreamReader(stream, Encoding.UTF8);
if (!streamReader.EndOfStream)
{
string text = "";
string text2 = streamReader.ReadLine();
do
{
string text3 = text2.Trim();
if (text3.StartsWith("#"))
{
continue;
}
if (text3.StartsWith("[") && text3.EndsWith("]"))
{
text = text3.Substring(1, text3.Length - 2);
continue;
}
string[] array = text3.Split('=');
if (array.Length == 2)
{
ConfigDefinition key = new ConfigDefinition(text, array[0].Trim());
if (Entries.TryGetValue(key, out var value))
{
value.SetSerializedValue(array[1].Trim());
}
else
{
OrphanedEntries[key] = array[1].Trim();
}
}
}
while ((text2 = streamReader.ReadLine()) != null);
}
}
OnConfigReloaded();
}
public void OnConfigReloaded()
{
Delegate[] array = this.ConfigReloaded?.GetInvocationList();
if (array == null)
{
return;
}
Delegate[] array2 = array;
foreach (Delegate @delegate in array2)
{
try
{
(@delegate as Action)?.Invoke();
}
catch (Exception ex)
{
Logger.LogError((object)ex);
}
}
}
public void OnSettingChanged(ZioConfigEntryBase changedSetting, object valueBefore, bool ignoreSave)
{
if (!ignoreSave && SaveOnConfigSet)
{
Save();
}
Delegate[] array = this.SettingChanged?.GetInvocationList();
if (array == null)
{
return;
}
Delegate[] array2 = array;
foreach (Delegate @delegate in array2)
{
try
{
(@delegate as Action<ZioConfigEntryBase, object>)?.Invoke(changedSetting, valueBefore);
}
catch (Exception ex)
{
Logger.LogError((object)ex);
}
}
}
protected virtual void SaveThread()
{
//IL_02bd: Unknown result type (might be due to invalid IL or missing references)
//IL_0239: Unknown result type (might be due to invalid IL or missing references)
//IL_023e: Unknown result type (might be due to invalid IL or missing references)
//IL_024a: Unknown result type (might be due to invalid IL or missing references)
//IL_024f: Unknown result type (might be due to invalid IL or missing references)
//IL_025b: Unknown result type (might be due to invalid IL or missing references)
//IL_0265: Unknown result type (might be due to invalid IL or missing references)
//IL_0295: Unknown result type (might be due to invalid IL or missing references)
//IL_029a: Unknown result type (might be due to invalid IL or missing references)
while (saveStopwatch.ElapsedMilliseconds < waitDuration)
{
Task.Delay(Mathf.FloorToInt((float)waitDuration * 0.1f));
}
using MemoryStream memoryStream = new MemoryStream();
using StreamWriter streamWriter = new StreamWriter(memoryStream, Encoding.UTF8);
if (OwnerMetadata != null)
{
streamWriter.WriteLine($"## Settings file was created by plugin {OwnerMetadata.Name} v{OwnerMetadata.Version}");
streamWriter.WriteLine("## Plugin GUID: " + OwnerMetadata.GUID);
streamWriter.WriteLine();
}
lock (_ioLock)
{
foreach (IGrouping<string, (ConfigDefinition, ZioConfigEntryBase, string)> item in from x in Entries.Select((KeyValuePair<ConfigDefinition, ZioConfigEntryBase> x) => (x.Key, x.Value, x.Value.GetSerializedValue())).Concat(((IEnumerable<KeyValuePair<ConfigDefinition, string>>)OrphanedEntries).Select((Func<KeyValuePair<ConfigDefinition, string>, (ConfigDefinition, ZioConfigEntryBase, string)>)((KeyValuePair<ConfigDefinition, string> x) => (x.Key, null, x.Value))))
group x by x.Key.Section into x
orderby x.Key
select x)
{
streamWriter.WriteLine("[" + item.Key + "]");
foreach (var item2 in item)
{
streamWriter.WriteLine();
item2.Item2?.WriteDescription(streamWriter);
streamWriter.WriteLine(item2.Item1.Key + " = " + item2.Item3);
}
streamWriter.WriteLine();
}
streamWriter.Flush();
}
try
{
UPath filePath = FilePath;
if (((UPath)(ref filePath)).IsNull)
{
goto IL_0278;
}
filePath = FilePath;
if (((UPath)(ref filePath)).IsEmpty || FilePath == UPath.op_Implicit("/"))
{
goto IL_0278;
}
FileSystem.CreateDirectory(UPathExtensions.GetDirectory(FilePath));
goto end_IL_0237;
IL_0278:
Logger.LogWarning((object)"Tried to create a ZioConfigFile with a null, empty or root path, escaping.");
return;
end_IL_0237:;
}
catch (UnauthorizedAccessException ex)
{
Debug.LogError((object)ex);
}
using Stream stream = FileSystem.OpenFile(FilePath, FileMode.Create, FileAccess.Write, FileShare.None);
stream.Write(memoryStream.GetBuffer(), 0, (int)memoryStream.Length);
stream.Close();
_waitingForSaves = false;
}
public void Save()
{
saveStopwatch.Restart();
if (!_waitingForSaves)
{
new Thread(SaveThread).Start();
}
_waitingForSaves = true;
}
public bool TryGetEntry<T>(string section, string key, out ZioConfigEntry<T> entry)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_000e: Expected O, but got Unknown
return TryGetEntry(new ConfigDefinition(section, key), out entry);
}
public bool TryGetEntry<T>(ConfigDefinition configDefinition, out ZioConfigEntry<T> entry)
{
lock (_ioLock)
{
if (Entries.TryGetValue(configDefinition, out var value))
{
entry = (ZioConfigEntry<T>)value;
return true;
}
entry = null;
return false;
}
}
public virtual ZioConfigEntry<T> Bind<T>(ConfigDefinition configDefinition, T defaultValue, ConfigDescription configDescription = null)
{
if (!TomlTypeConverter.CanConvert(typeof(T)))
{
throw new ArgumentException(string.Format("Type {0} is not supported by the config system. Supported types: {1}", typeof(T), string.Join(", ", (from x in TomlTypeConverter.GetSupportedTypes()
select x.Name).ToArray())));
}
lock (_ioLock)
{
if (Entries.TryGetValue(configDefinition, out var value))
{
return (ZioConfigEntry<T>)value;
}
ZioConfigEntry<T> zioConfigEntry = new ZioConfigEntry<T>(configDefinition, defaultValue, configDescription);
Entries[configDefinition] = zioConfigEntry;
zioConfigEntry.SettingChanged += OnSettingChanged;
if (OrphanedEntries.TryGetValue(configDefinition, out var value2))
{
zioConfigEntry.SetSerializedValue(value2);
OrphanedEntries.Remove(configDefinition);
}
if (SaveOnConfigSet)
{
Save();
}
return zioConfigEntry;
}
}
public ZioConfigEntry<T> Bind<T>(string section, string key, T defaultValue, string description)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_001b: Expected O, but got Unknown
return Bind(new ConfigDefinition(section, key), defaultValue, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()));
}
public ZioConfigEntry<T> Bind<T>(string section, string key, T defaultValue, ConfigDescription configDescription = null)
{
//IL_0003: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
return Bind(new ConfigDefinition(section, key), defaultValue, configDescription);
}
public IEnumerator<KeyValuePair<ConfigDefinition, ZioConfigEntryBase>> GetEnumerator()
{
return Entries.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
void ICollection<KeyValuePair<ConfigDefinition, ZioConfigEntryBase>>.Add(KeyValuePair<ConfigDefinition, ZioConfigEntryBase> item)
{
lock (_ioLock)
{
Entries.Add(item.Key, item.Value);
}
}
public bool Contains(KeyValuePair<ConfigDefinition, ZioConfigEntryBase> item)
{
return Entries.Contains(item);
}
public void CopyTo(KeyValuePair<ConfigDefinition, ZioConfigEntryBase>[] array, int arrayIndex)
{
lock (_ioLock)
{
((ICollection<KeyValuePair<ConfigDefinition, ZioConfigEntryBase>>)Entries).CopyTo(array, arrayIndex);
}
}
public bool Remove(KeyValuePair<ConfigDefinition, ZioConfigEntryBase> item)
{
lock (_ioLock)
{
return Entries.Remove(item.Key);
}
}
public bool ContainsKey(ConfigDefinition key)
{
lock (_ioLock)
{
return Entries.ContainsKey(key);
}
}
public void Add(ConfigDefinition key, ZioConfigEntryBase value)
{
throw new InvalidOperationException("Directly adding a config entry is not supported");
}
public bool Remove(ConfigDefinition key)
{
lock (_ioLock)
{
return Entries.Remove(key);
}
}
public void Clear()
{
lock (_ioLock)
{
Entries.Clear();
}
}
public bool TryGetValue(ConfigDefinition key, out ZioConfigEntryBase value)
{
lock (_ioLock)
{
return Entries.TryGetValue(key, out value);
}
}
}
[BepInPlugin("bubbet.zioconfigfile", "Zio Config File", "1.0.1")]
public class ZioConfigFilePlugin : BaseUnityPlugin
{
}
}
