Decompiled source of Grey Announcer v1.1.1
Newtonsoft.Json.dll
Decompiled a month ago
The result has been truncated due to the large size, download it to view full contents!
using System; using System.Collections; using System.Collections.Concurrent; using System.Collections.Generic; using System.Collections.ObjectModel; using System.Collections.Specialized; using System.ComponentModel; using System.Data; using System.Data.SqlTypes; using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Dynamic; using System.Globalization; using System.IO; using System.Linq; using System.Linq.Expressions; using System.Numerics; using System.Reflection; using System.Reflection.Emit; using System.Resources; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Serialization; using System.Runtime.Serialization.Formatters; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using System.Text; using System.Text.RegularExpressions; using System.Threading; using System.Threading.Tasks; using System.Xml; using System.Xml.Linq; using Microsoft.CodeAnalysis; using Newtonsoft.Json.Bson; using Newtonsoft.Json.Converters; using Newtonsoft.Json.Linq; using Newtonsoft.Json.Linq.JsonPath; using Newtonsoft.Json.Schema; using Newtonsoft.Json.Serialization; using Newtonsoft.Json.Utilities; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: AllowPartiallyTrustedCallers] [assembly: InternalsVisibleTo("Newtonsoft.Json.Schema, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")] [assembly: InternalsVisibleTo("Newtonsoft.Json.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")] [assembly: InternalsVisibleTo("Newtonsoft.Json.Dynamic, PublicKey=0024000004800000940000000602000000240000525341310004000001000100cbd8d53b9d7de30f1f1278f636ec462cf9c254991291e66ebb157a885638a517887633b898ccbcf0d5c5ff7be85a6abe9e765d0ac7cd33c68dac67e7e64530e8222101109f154ab14a941c490ac155cd1d4fcba0fabb49016b4ef28593b015cab5937da31172f03f67d09edda404b88a60023f062ae71d0b2e4438b74cc11dc9")] [assembly: AssemblyTrademark("")] [assembly: ComVisible(false)] [assembly: Guid("9ca358aa-317b-4925-8ada-4a29e943a363")] [assembly: CLSCompliant(true)] [assembly: TargetFramework(".NETFramework,Version=v4.5", FrameworkDisplayName = ".NET Framework 4.5")] [assembly: AssemblyCompany("Newtonsoft")] [assembly: AssemblyConfiguration("Release")] [assembly: AssemblyCopyright("Copyright © James Newton-King 2008")] [assembly: AssemblyDescription("Json.NET is a popular high-performance JSON framework for .NET")] [assembly: AssemblyFileVersion("13.0.3.27908")] [assembly: AssemblyInformationalVersion("13.0.3+0a2e291c0d9c0c7675d445703e51750363a549ef")] [assembly: AssemblyProduct("Json.NET")] [assembly: AssemblyTitle("Json.NET .NET 4.5")] [assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/JamesNK/Newtonsoft.Json")] [assembly: NeutralResourcesLanguage("en-US")] [assembly: AssemblyVersion("13.0.0.0")] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] internal sealed class EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] internal sealed class IsReadOnlyAttribute : Attribute { } [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)] 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] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)] internal sealed class NullableContextAttribute : Attribute { public readonly byte Flag; public NullableContextAttribute(byte P_0) { Flag = P_0; } } } namespace System.Diagnostics.CodeAnalysis { [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true)] internal sealed class NotNullAttribute : Attribute { } [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)] internal sealed class NotNullWhenAttribute : Attribute { public bool ReturnValue { get; } public NotNullWhenAttribute(bool returnValue) { ReturnValue = returnValue; } } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)] internal sealed class MaybeNullAttribute : Attribute { } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)] internal sealed class AllowNullAttribute : Attribute { } [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] internal class DoesNotReturnIfAttribute : Attribute { public bool ParameterValue { get; } public DoesNotReturnIfAttribute(bool parameterValue) { ParameterValue = parameterValue; } } } namespace Newtonsoft.Json { public enum ConstructorHandling { Default, AllowNonPublicDefaultConstructor } public enum DateFormatHandling { IsoDateFormat, MicrosoftDateFormat } public enum DateParseHandling { None, DateTime, DateTimeOffset } public enum DateTimeZoneHandling { Local, Utc, Unspecified, RoundtripKind } public class DefaultJsonNameTable : JsonNameTable { private class Entry { internal readonly string Value; internal readonly int HashCode; internal Entry Next; internal Entry(string value, int hashCode, Entry next) { Value = value; HashCode = hashCode; Next = next; } } private static readonly int HashCodeRandomizer; private int _count; private Entry[] _entries; private int _mask = 31; static DefaultJsonNameTable() { HashCodeRandomizer = Environment.TickCount; } public DefaultJsonNameTable() { _entries = new Entry[_mask + 1]; } public override string? Get(char[] key, int start, int length) { if (length == 0) { return string.Empty; } int num = length + HashCodeRandomizer; num += (num << 7) ^ key[start]; int num2 = start + length; for (int i = start + 1; i < num2; i++) { num += (num << 7) ^ key[i]; } num -= num >> 17; num -= num >> 11; num -= num >> 5; int num3 = Volatile.Read(ref _mask); int num4 = num & num3; for (Entry entry = _entries[num4]; entry != null; entry = entry.Next) { if (entry.HashCode == num && TextEquals(entry.Value, key, start, length)) { return entry.Value; } } return null; } public string Add(string key) { if (key == null) { throw new ArgumentNullException("key"); } int length = key.Length; if (length == 0) { return string.Empty; } int num = length + HashCodeRandomizer; for (int i = 0; i < key.Length; i++) { num += (num << 7) ^ key[i]; } num -= num >> 17; num -= num >> 11; num -= num >> 5; for (Entry entry = _entries[num & _mask]; entry != null; entry = entry.Next) { if (entry.HashCode == num && entry.Value.Equals(key, StringComparison.Ordinal)) { return entry.Value; } } return AddEntry(key, num); } private string AddEntry(string str, int hashCode) { int num = hashCode & _mask; Entry entry = new Entry(str, hashCode, _entries[num]); _entries[num] = entry; if (_count++ == _mask) { Grow(); } return entry.Value; } private void Grow() { Entry[] entries = _entries; int num = _mask * 2 + 1; Entry[] array = new Entry[num + 1]; for (int i = 0; i < entries.Length; i++) { Entry entry = entries[i]; while (entry != null) { int num2 = entry.HashCode & num; Entry next = entry.Next; entry.Next = array[num2]; array[num2] = entry; entry = next; } } _entries = array; Volatile.Write(ref _mask, num); } private static bool TextEquals(string str1, char[] str2, int str2Start, int str2Length) { if (str1.Length != str2Length) { return false; } for (int i = 0; i < str1.Length; i++) { if (str1[i] != str2[str2Start + i]) { return false; } } return true; } } [Flags] public enum DefaultValueHandling { Include = 0, Ignore = 1, Populate = 2, IgnoreAndPopulate = 3 } public enum FloatFormatHandling { String, Symbol, DefaultValue } public enum FloatParseHandling { Double, Decimal } public enum Formatting { None, Indented } public interface IArrayPool<T> { T[] Rent(int minimumLength); void Return(T[]? array); } public interface IJsonLineInfo { int LineNumber { get; } int LinePosition { get; } bool HasLineInfo(); } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)] public sealed class JsonArrayAttribute : JsonContainerAttribute { private bool _allowNullItems; public bool AllowNullItems { get { return _allowNullItems; } set { _allowNullItems = value; } } public JsonArrayAttribute() { } public JsonArrayAttribute(bool allowNullItems) { _allowNullItems = allowNullItems; } public JsonArrayAttribute(string id) : base(id) { } } [AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)] public sealed class JsonConstructorAttribute : Attribute { } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)] public abstract class JsonContainerAttribute : Attribute { internal bool? _isReference; internal bool? _itemIsReference; internal ReferenceLoopHandling? _itemReferenceLoopHandling; internal TypeNameHandling? _itemTypeNameHandling; private Type? _namingStrategyType; private object[]? _namingStrategyParameters; public string? Id { get; set; } public string? Title { get; set; } public string? Description { get; set; } public Type? ItemConverterType { get; set; } public object[]? ItemConverterParameters { get; set; } public Type? NamingStrategyType { get { return _namingStrategyType; } set { _namingStrategyType = value; NamingStrategyInstance = null; } } public object[]? NamingStrategyParameters { get { return _namingStrategyParameters; } set { _namingStrategyParameters = value; NamingStrategyInstance = null; } } internal NamingStrategy? NamingStrategyInstance { get; set; } public bool IsReference { get { return _isReference.GetValueOrDefault(); } set { _isReference = value; } } public bool ItemIsReference { get { return _itemIsReference.GetValueOrDefault(); } set { _itemIsReference = value; } } public ReferenceLoopHandling ItemReferenceLoopHandling { get { return _itemReferenceLoopHandling.GetValueOrDefault(); } set { _itemReferenceLoopHandling = value; } } public TypeNameHandling ItemTypeNameHandling { get { return _itemTypeNameHandling.GetValueOrDefault(); } set { _itemTypeNameHandling = value; } } protected JsonContainerAttribute() { } protected JsonContainerAttribute(string id) { Id = id; } } public static class JsonConvert { public static readonly string True = "true"; public static readonly string False = "false"; public static readonly string Null = "null"; public static readonly string Undefined = "undefined"; public static readonly string PositiveInfinity = "Infinity"; public static readonly string NegativeInfinity = "-Infinity"; public static readonly string NaN = "NaN"; public static Func<JsonSerializerSettings>? DefaultSettings { get; set; } public static string ToString(DateTime value) { return ToString(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.RoundtripKind); } public static string ToString(DateTime value, DateFormatHandling format, DateTimeZoneHandling timeZoneHandling) { DateTime value2 = DateTimeUtils.EnsureDateTime(value, timeZoneHandling); using StringWriter stringWriter = StringUtils.CreateStringWriter(64); stringWriter.Write('"'); DateTimeUtils.WriteDateTimeString(stringWriter, value2, format, null, CultureInfo.InvariantCulture); stringWriter.Write('"'); return stringWriter.ToString(); } public static string ToString(DateTimeOffset value) { return ToString(value, DateFormatHandling.IsoDateFormat); } public static string ToString(DateTimeOffset value, DateFormatHandling format) { using StringWriter stringWriter = StringUtils.CreateStringWriter(64); stringWriter.Write('"'); DateTimeUtils.WriteDateTimeOffsetString(stringWriter, value, format, null, CultureInfo.InvariantCulture); stringWriter.Write('"'); return stringWriter.ToString(); } public static string ToString(bool value) { if (!value) { return False; } return True; } public static string ToString(char value) { return ToString(char.ToString(value)); } public static string ToString(Enum value) { return value.ToString("D"); } public static string ToString(int value) { return value.ToString(null, CultureInfo.InvariantCulture); } public static string ToString(short value) { return value.ToString(null, CultureInfo.InvariantCulture); } [CLSCompliant(false)] public static string ToString(ushort value) { return value.ToString(null, CultureInfo.InvariantCulture); } [CLSCompliant(false)] public static string ToString(uint value) { return value.ToString(null, CultureInfo.InvariantCulture); } public static string ToString(long value) { return value.ToString(null, CultureInfo.InvariantCulture); } private static string ToStringInternal(BigInteger value) { return value.ToString(null, CultureInfo.InvariantCulture); } [CLSCompliant(false)] public static string ToString(ulong value) { return value.ToString(null, CultureInfo.InvariantCulture); } public static string ToString(float value) { return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)); } internal static string ToString(float value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable) { return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable); } private static string EnsureFloatFormat(double value, string text, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable) { if (floatFormatHandling == FloatFormatHandling.Symbol || (!double.IsInfinity(value) && !double.IsNaN(value))) { return text; } if (floatFormatHandling == FloatFormatHandling.DefaultValue) { if (nullable) { return Null; } return "0.0"; } return quoteChar + text + quoteChar; } public static string ToString(double value) { return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)); } internal static string ToString(double value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable) { return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable); } private static string EnsureDecimalPlace(double value, string text) { if (double.IsNaN(value) || double.IsInfinity(value) || StringUtils.IndexOf(text, '.') != -1 || StringUtils.IndexOf(text, 'E') != -1 || StringUtils.IndexOf(text, 'e') != -1) { return text; } return text + ".0"; } private static string EnsureDecimalPlace(string text) { if (StringUtils.IndexOf(text, '.') != -1) { return text; } return text + ".0"; } public static string ToString(byte value) { return value.ToString(null, CultureInfo.InvariantCulture); } [CLSCompliant(false)] public static string ToString(sbyte value) { return value.ToString(null, CultureInfo.InvariantCulture); } public static string ToString(decimal value) { return EnsureDecimalPlace(value.ToString(null, CultureInfo.InvariantCulture)); } public static string ToString(Guid value) { return ToString(value, '"'); } internal static string ToString(Guid value, char quoteChar) { string text = value.ToString("D", CultureInfo.InvariantCulture); string text2 = quoteChar.ToString(CultureInfo.InvariantCulture); return text2 + text + text2; } public static string ToString(TimeSpan value) { return ToString(value, '"'); } internal static string ToString(TimeSpan value, char quoteChar) { return ToString(value.ToString(), quoteChar); } public static string ToString(Uri? value) { if (value == null) { return Null; } return ToString(value, '"'); } internal static string ToString(Uri value, char quoteChar) { return ToString(value.OriginalString, quoteChar); } public static string ToString(string? value) { return ToString(value, '"'); } public static string ToString(string? value, char delimiter) { return ToString(value, delimiter, StringEscapeHandling.Default); } public static string ToString(string? value, char delimiter, StringEscapeHandling stringEscapeHandling) { if (delimiter != '"' && delimiter != '\'') { throw new ArgumentException("Delimiter must be a single or double quote.", "delimiter"); } return JavaScriptUtils.ToEscapedJavaScriptString(value, delimiter, appendDelimiters: true, stringEscapeHandling); } public static string ToString(object? value) { if (value == null) { return Null; } return ConvertUtils.GetTypeCode(value.GetType()) switch { PrimitiveTypeCode.String => ToString((string)value), PrimitiveTypeCode.Char => ToString((char)value), PrimitiveTypeCode.Boolean => ToString((bool)value), PrimitiveTypeCode.SByte => ToString((sbyte)value), PrimitiveTypeCode.Int16 => ToString((short)value), PrimitiveTypeCode.UInt16 => ToString((ushort)value), PrimitiveTypeCode.Int32 => ToString((int)value), PrimitiveTypeCode.Byte => ToString((byte)value), PrimitiveTypeCode.UInt32 => ToString((uint)value), PrimitiveTypeCode.Int64 => ToString((long)value), PrimitiveTypeCode.UInt64 => ToString((ulong)value), PrimitiveTypeCode.Single => ToString((float)value), PrimitiveTypeCode.Double => ToString((double)value), PrimitiveTypeCode.DateTime => ToString((DateTime)value), PrimitiveTypeCode.Decimal => ToString((decimal)value), PrimitiveTypeCode.DBNull => Null, PrimitiveTypeCode.DateTimeOffset => ToString((DateTimeOffset)value), PrimitiveTypeCode.Guid => ToString((Guid)value), PrimitiveTypeCode.Uri => ToString((Uri)value), PrimitiveTypeCode.TimeSpan => ToString((TimeSpan)value), PrimitiveTypeCode.BigInteger => ToStringInternal((BigInteger)value), _ => throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType())), }; } [DebuggerStepThrough] public static string SerializeObject(object? value) { return SerializeObject(value, (Type?)null, (JsonSerializerSettings?)null); } [DebuggerStepThrough] public static string SerializeObject(object? value, Formatting formatting) { return SerializeObject(value, formatting, (JsonSerializerSettings?)null); } [DebuggerStepThrough] public static string SerializeObject(object? value, params JsonConverter[] converters) { JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings { Converters = converters } : null); return SerializeObject(value, null, settings); } [DebuggerStepThrough] public static string SerializeObject(object? value, Formatting formatting, params JsonConverter[] converters) { JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings { Converters = converters } : null); return SerializeObject(value, null, formatting, settings); } [DebuggerStepThrough] public static string SerializeObject(object? value, JsonSerializerSettings? settings) { return SerializeObject(value, null, settings); } [DebuggerStepThrough] public static string SerializeObject(object? value, Type? type, JsonSerializerSettings? settings) { JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings); return SerializeObjectInternal(value, type, jsonSerializer); } [DebuggerStepThrough] public static string SerializeObject(object? value, Formatting formatting, JsonSerializerSettings? settings) { return SerializeObject(value, null, formatting, settings); } [DebuggerStepThrough] public static string SerializeObject(object? value, Type? type, Formatting formatting, JsonSerializerSettings? settings) { JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings); jsonSerializer.Formatting = formatting; return SerializeObjectInternal(value, type, jsonSerializer); } private static string SerializeObjectInternal(object? value, Type? type, JsonSerializer jsonSerializer) { StringWriter stringWriter = new StringWriter(new StringBuilder(256), CultureInfo.InvariantCulture); using (JsonTextWriter jsonTextWriter = new JsonTextWriter(stringWriter)) { jsonTextWriter.Formatting = jsonSerializer.Formatting; jsonSerializer.Serialize(jsonTextWriter, value, type); } return stringWriter.ToString(); } [DebuggerStepThrough] public static object? DeserializeObject(string value) { return DeserializeObject(value, (Type?)null, (JsonSerializerSettings?)null); } [DebuggerStepThrough] public static object? DeserializeObject(string value, JsonSerializerSettings settings) { return DeserializeObject(value, null, settings); } [DebuggerStepThrough] public static object? DeserializeObject(string value, Type type) { return DeserializeObject(value, type, (JsonSerializerSettings?)null); } [DebuggerStepThrough] public static T? DeserializeObject<T>(string value) { return JsonConvert.DeserializeObject<T>(value, (JsonSerializerSettings?)null); } [DebuggerStepThrough] public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject) { return DeserializeObject<T>(value); } [DebuggerStepThrough] public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject, JsonSerializerSettings settings) { return DeserializeObject<T>(value, settings); } [DebuggerStepThrough] public static T? DeserializeObject<T>(string value, params JsonConverter[] converters) { return (T)DeserializeObject(value, typeof(T), converters); } [DebuggerStepThrough] public static T? DeserializeObject<T>(string value, JsonSerializerSettings? settings) { return (T)DeserializeObject(value, typeof(T), settings); } [DebuggerStepThrough] public static object? DeserializeObject(string value, Type type, params JsonConverter[] converters) { JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings { Converters = converters } : null); return DeserializeObject(value, type, settings); } public static object? DeserializeObject(string value, Type? type, JsonSerializerSettings? settings) { ValidationUtils.ArgumentNotNull(value, "value"); JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings); if (!jsonSerializer.IsCheckAdditionalContentSet()) { jsonSerializer.CheckAdditionalContent = true; } using JsonTextReader reader = new JsonTextReader(new StringReader(value)); return jsonSerializer.Deserialize(reader, type); } [DebuggerStepThrough] public static void PopulateObject(string value, object target) { PopulateObject(value, target, null); } public static void PopulateObject(string value, object target, JsonSerializerSettings? settings) { JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings); using JsonReader jsonReader = new JsonTextReader(new StringReader(value)); jsonSerializer.Populate(jsonReader, target); if (settings == null || !settings.CheckAdditionalContent) { return; } while (jsonReader.Read()) { if (jsonReader.TokenType != JsonToken.Comment) { throw JsonSerializationException.Create(jsonReader, "Additional text found in JSON string after finishing deserializing object."); } } } public static string SerializeXmlNode(XmlNode? node) { return SerializeXmlNode(node, Formatting.None); } public static string SerializeXmlNode(XmlNode? node, Formatting formatting) { XmlNodeConverter xmlNodeConverter = new XmlNodeConverter(); return SerializeObject(node, formatting, xmlNodeConverter); } public static string SerializeXmlNode(XmlNode? node, Formatting formatting, bool omitRootObject) { XmlNodeConverter xmlNodeConverter = new XmlNodeConverter { OmitRootObject = omitRootObject }; return SerializeObject(node, formatting, xmlNodeConverter); } public static XmlDocument? DeserializeXmlNode(string value) { return DeserializeXmlNode(value, null); } public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName) { return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute: false); } public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute) { return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false); } public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters) { XmlNodeConverter xmlNodeConverter = new XmlNodeConverter(); xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName; xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute; xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters; return (XmlDocument)DeserializeObject(value, typeof(XmlDocument), xmlNodeConverter); } public static string SerializeXNode(XObject? node) { return SerializeXNode(node, Formatting.None); } public static string SerializeXNode(XObject? node, Formatting formatting) { return SerializeXNode(node, formatting, omitRootObject: false); } public static string SerializeXNode(XObject? node, Formatting formatting, bool omitRootObject) { XmlNodeConverter xmlNodeConverter = new XmlNodeConverter { OmitRootObject = omitRootObject }; return SerializeObject(node, formatting, xmlNodeConverter); } public static XDocument? DeserializeXNode(string value) { return DeserializeXNode(value, null); } public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName) { return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute: false); } public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute) { return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false); } public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters) { //IL_0035: Unknown result type (might be due to invalid IL or missing references) //IL_003b: Expected O, but got Unknown XmlNodeConverter xmlNodeConverter = new XmlNodeConverter(); xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName; xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute; xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters; return (XDocument)DeserializeObject(value, typeof(XDocument), xmlNodeConverter); } } public abstract class JsonConverter { public virtual bool CanRead => true; public virtual bool CanWrite => true; public abstract void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer); public abstract object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer); public abstract bool CanConvert(Type objectType); } public abstract class JsonConverter<T> : JsonConverter { public sealed override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer) { if (!((value != null) ? (value is T) : ReflectionUtils.IsNullable(typeof(T)))) { throw new JsonSerializationException("Converter cannot write specified value to JSON. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T))); } WriteJson(writer, (T)value, serializer); } public abstract void WriteJson(JsonWriter writer, T? value, JsonSerializer serializer); public sealed override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer) { bool flag = existingValue == null; if (!flag && !(existingValue is T)) { throw new JsonSerializationException("Converter cannot read JSON with the specified existing value. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T))); } return ReadJson(reader, objectType, flag ? default(T) : ((T)existingValue), !flag, serializer); } public abstract T? ReadJson(JsonReader reader, Type objectType, T? existingValue, bool hasExistingValue, JsonSerializer serializer); public sealed override bool CanConvert(Type objectType) { return typeof(T).IsAssignableFrom(objectType); } } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter, AllowMultiple = false)] public sealed class JsonConverterAttribute : Attribute { private readonly Type _converterType; public Type ConverterType => _converterType; public object[]? ConverterParameters { get; } public JsonConverterAttribute(Type converterType) { if (converterType == null) { throw new ArgumentNullException("converterType"); } _converterType = converterType; } public JsonConverterAttribute(Type converterType, params object[] converterParameters) : this(converterType) { ConverterParameters = converterParameters; } } public class JsonConverterCollection : Collection<JsonConverter> { } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)] public sealed class JsonDictionaryAttribute : JsonContainerAttribute { public JsonDictionaryAttribute() { } public JsonDictionaryAttribute(string id) : base(id) { } } [Serializable] public class JsonException : Exception { public JsonException() { } public JsonException(string message) : base(message) { } public JsonException(string message, Exception? innerException) : base(message, innerException) { } public JsonException(SerializationInfo info, StreamingContext context) : base(info, context) { } internal static JsonException Create(IJsonLineInfo lineInfo, string path, string message) { message = JsonPosition.FormatMessage(lineInfo, path, message); return new JsonException(message); } } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)] public class JsonExtensionDataAttribute : Attribute { public bool WriteData { get; set; } public bool ReadData { get; set; } public JsonExtensionDataAttribute() { WriteData = true; ReadData = true; } } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)] public sealed class JsonIgnoreAttribute : Attribute { } public abstract class JsonNameTable { public abstract string? Get(char[] key, int start, int length); } [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, AllowMultiple = false)] public sealed class JsonObjectAttribute : JsonContainerAttribute { private MemberSerialization _memberSerialization; internal MissingMemberHandling? _missingMemberHandling; internal Required? _itemRequired; internal NullValueHandling? _itemNullValueHandling; public MemberSerialization MemberSerialization { get { return _memberSerialization; } set { _memberSerialization = value; } } public MissingMemberHandling MissingMemberHandling { get { return _missingMemberHandling.GetValueOrDefault(); } set { _missingMemberHandling = value; } } public NullValueHandling ItemNullValueHandling { get { return _itemNullValueHandling.GetValueOrDefault(); } set { _itemNullValueHandling = value; } } public Required ItemRequired { get { return _itemRequired.GetValueOrDefault(); } set { _itemRequired = value; } } public JsonObjectAttribute() { } public JsonObjectAttribute(MemberSerialization memberSerialization) { MemberSerialization = memberSerialization; } public JsonObjectAttribute(string id) : base(id) { } } internal enum JsonContainerType { None, Object, Array, Constructor } internal struct JsonPosition { private static readonly char[] SpecialCharacters = new char[18] { '.', ' ', '\'', '/', '"', '[', ']', '(', ')', '\t', '\n', '\r', '\f', '\b', '\\', '\u0085', '\u2028', '\u2029' }; internal JsonContainerType Type; internal int Position; internal string? PropertyName; internal bool HasIndex; public JsonPosition(JsonContainerType type) { Type = type; HasIndex = TypeHasIndex(type); Position = -1; PropertyName = null; } internal int CalculateLength() { switch (Type) { case JsonContainerType.Object: return PropertyName.Length + 5; case JsonContainerType.Array: case JsonContainerType.Constructor: return MathUtils.IntLength((ulong)Position) + 2; default: throw new ArgumentOutOfRangeException("Type"); } } internal void WriteTo(StringBuilder sb, ref StringWriter? writer, ref char[]? buffer) { switch (Type) { case JsonContainerType.Object: { string propertyName = PropertyName; if (propertyName.IndexOfAny(SpecialCharacters) != -1) { sb.Append("['"); if (writer == null) { writer = new StringWriter(sb); } JavaScriptUtils.WriteEscapedJavaScriptString(writer, propertyName, '\'', appendDelimiters: false, JavaScriptUtils.SingleQuoteCharEscapeFlags, StringEscapeHandling.Default, null, ref buffer); sb.Append("']"); } else { if (sb.Length > 0) { sb.Append('.'); } sb.Append(propertyName); } break; } case JsonContainerType.Array: case JsonContainerType.Constructor: sb.Append('['); sb.Append(Position); sb.Append(']'); break; } } internal static bool TypeHasIndex(JsonContainerType type) { if (type != JsonContainerType.Array) { return type == JsonContainerType.Constructor; } return true; } internal static string BuildPath(List<JsonPosition> positions, JsonPosition? currentPosition) { int num = 0; if (positions != null) { for (int i = 0; i < positions.Count; i++) { num += positions[i].CalculateLength(); } } if (currentPosition.HasValue) { num += currentPosition.GetValueOrDefault().CalculateLength(); } StringBuilder stringBuilder = new StringBuilder(num); StringWriter writer = null; char[] buffer = null; if (positions != null) { foreach (JsonPosition position in positions) { position.WriteTo(stringBuilder, ref writer, ref buffer); } } currentPosition?.WriteTo(stringBuilder, ref writer, ref buffer); return stringBuilder.ToString(); } internal static string FormatMessage(IJsonLineInfo? lineInfo, string path, string message) { if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal)) { message = message.Trim(); if (!StringUtils.EndsWith(message, '.')) { message += "."; } message += " "; } message += "Path '{0}'".FormatWith(CultureInfo.InvariantCulture, path); if (lineInfo != null && lineInfo.HasLineInfo()) { message += ", line {0}, position {1}".FormatWith(CultureInfo.InvariantCulture, lineInfo.LineNumber, lineInfo.LinePosition); } message += "."; return message; } } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false)] public sealed class JsonPropertyAttribute : Attribute { internal NullValueHandling? _nullValueHandling; internal DefaultValueHandling? _defaultValueHandling; internal ReferenceLoopHandling? _referenceLoopHandling; internal ObjectCreationHandling? _objectCreationHandling; internal TypeNameHandling? _typeNameHandling; internal bool? _isReference; internal int? _order; internal Required? _required; internal bool? _itemIsReference; internal ReferenceLoopHandling? _itemReferenceLoopHandling; internal TypeNameHandling? _itemTypeNameHandling; public Type? ItemConverterType { get; set; } public object[]? ItemConverterParameters { get; set; } public Type? NamingStrategyType { get; set; } public object[]? NamingStrategyParameters { get; set; } public NullValueHandling NullValueHandling { get { return _nullValueHandling.GetValueOrDefault(); } set { _nullValueHandling = value; } } public DefaultValueHandling DefaultValueHandling { get { return _defaultValueHandling.GetValueOrDefault(); } set { _defaultValueHandling = value; } } public ReferenceLoopHandling ReferenceLoopHandling { get { return _referenceLoopHandling.GetValueOrDefault(); } set { _referenceLoopHandling = value; } } public ObjectCreationHandling ObjectCreationHandling { get { return _objectCreationHandling.GetValueOrDefault(); } set { _objectCreationHandling = value; } } public TypeNameHandling TypeNameHandling { get { return _typeNameHandling.GetValueOrDefault(); } set { _typeNameHandling = value; } } public bool IsReference { get { return _isReference.GetValueOrDefault(); } set { _isReference = value; } } public int Order { get { return _order.GetValueOrDefault(); } set { _order = value; } } public Required Required { get { return _required.GetValueOrDefault(); } set { _required = value; } } public string? PropertyName { get; set; } public ReferenceLoopHandling ItemReferenceLoopHandling { get { return _itemReferenceLoopHandling.GetValueOrDefault(); } set { _itemReferenceLoopHandling = value; } } public TypeNameHandling ItemTypeNameHandling { get { return _itemTypeNameHandling.GetValueOrDefault(); } set { _itemTypeNameHandling = value; } } public bool ItemIsReference { get { return _itemIsReference.GetValueOrDefault(); } set { _itemIsReference = value; } } public JsonPropertyAttribute() { } public JsonPropertyAttribute(string propertyName) { PropertyName = propertyName; } } public abstract class JsonReader : IDisposable { protected internal enum State { Start, Complete, Property, ObjectStart, Object, ArrayStart, Array, Closed, PostValue, ConstructorStart, Constructor, Error, Finished } private JsonToken _tokenType; private object? _value; internal char _quoteChar; internal State _currentState; private JsonPosition _currentPosition; private CultureInfo? _culture; private DateTimeZoneHandling _dateTimeZoneHandling; private int? _maxDepth; private bool _hasExceededMaxDepth; internal DateParseHandling _dateParseHandling; internal FloatParseHandling _floatParseHandling; private string? _dateFormatString; private List<JsonPosition>? _stack; protected State CurrentState => _currentState; public bool CloseInput { get; set; } public bool SupportMultipleContent { get; set; } public virtual char QuoteChar { get { return _quoteChar; } protected internal set { _quoteChar = value; } } public DateTimeZoneHandling DateTimeZoneHandling { get { return _dateTimeZoneHandling; } set { if (value < DateTimeZoneHandling.Local || value > DateTimeZoneHandling.RoundtripKind) { throw new ArgumentOutOfRangeException("value"); } _dateTimeZoneHandling = value; } } public DateParseHandling DateParseHandling { get { return _dateParseHandling; } set { if (value < DateParseHandling.None || value > DateParseHandling.DateTimeOffset) { throw new ArgumentOutOfRangeException("value"); } _dateParseHandling = value; } } public FloatParseHandling FloatParseHandling { get { return _floatParseHandling; } set { if (value < FloatParseHandling.Double || value > FloatParseHandling.Decimal) { throw new ArgumentOutOfRangeException("value"); } _floatParseHandling = value; } } public string? DateFormatString { get { return _dateFormatString; } set { _dateFormatString = value; } } public int? MaxDepth { get { return _maxDepth; } set { if (value <= 0) { throw new ArgumentException("Value must be positive.", "value"); } _maxDepth = value; } } public virtual JsonToken TokenType => _tokenType; public virtual object? Value => _value; public virtual Type? ValueType => _value?.GetType(); public virtual int Depth { get { int num = _stack?.Count ?? 0; if (JsonTokenUtils.IsStartToken(TokenType) || _currentPosition.Type == JsonContainerType.None) { return num; } return num + 1; } } public virtual string Path { get { if (_currentPosition.Type == JsonContainerType.None) { return string.Empty; } JsonPosition? currentPosition = ((_currentState != State.ArrayStart && _currentState != State.ConstructorStart && _currentState != State.ObjectStart) ? new JsonPosition?(_currentPosition) : null); return JsonPosition.BuildPath(_stack, currentPosition); } } public CultureInfo Culture { get { return _culture ?? CultureInfo.InvariantCulture; } set { _culture = value; } } public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default(CancellationToken)) { return cancellationToken.CancelIfRequestedAsync<bool>() ?? Read().ToAsync(); } public async Task SkipAsync(CancellationToken cancellationToken = default(CancellationToken)) { if (TokenType == JsonToken.PropertyName) { await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false); } if (JsonTokenUtils.IsStartToken(TokenType)) { int depth = Depth; while (await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false) && depth < Depth) { } } } internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken) { if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false))) { throw CreateUnexpectedEndException(); } } public virtual Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default(CancellationToken)) { return cancellationToken.CancelIfRequestedAsync<bool?>() ?? Task.FromResult(ReadAsBoolean()); } public virtual Task<byte[]?> ReadAsBytesAsync(CancellationToken cancellationToken = default(CancellationToken)) { return cancellationToken.CancelIfRequestedAsync<byte[]>() ?? Task.FromResult(ReadAsBytes()); } internal async Task<byte[]?> ReadArrayIntoByteArrayAsync(CancellationToken cancellationToken) { List<byte> buffer = new List<byte>(); do { if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false))) { SetToken(JsonToken.None); } } while (!ReadArrayElementIntoByteArrayReportDone(buffer)); byte[] array = buffer.ToArray(); SetToken(JsonToken.Bytes, array, updateIndex: false); return array; } public virtual Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default(CancellationToken)) { return cancellationToken.CancelIfRequestedAsync<DateTime?>() ?? Task.FromResult(ReadAsDateTime()); } public virtual Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default(CancellationToken)) { return cancellationToken.CancelIfRequestedAsync<DateTimeOffset?>() ?? Task.FromResult(ReadAsDateTimeOffset()); } public virtual Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default(CancellationToken)) { return cancellationToken.CancelIfRequestedAsync<decimal?>() ?? Task.FromResult(ReadAsDecimal()); } public virtual Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default(CancellationToken)) { return Task.FromResult(ReadAsDouble()); } public virtual Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default(CancellationToken)) { return cancellationToken.CancelIfRequestedAsync<int?>() ?? Task.FromResult(ReadAsInt32()); } public virtual Task<string?> ReadAsStringAsync(CancellationToken cancellationToken = default(CancellationToken)) { return cancellationToken.CancelIfRequestedAsync<string>() ?? Task.FromResult(ReadAsString()); } internal async Task<bool> ReadAndMoveToContentAsync(CancellationToken cancellationToken) { bool flag = await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false); if (flag) { flag = await MoveToContentAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false); } return flag; } internal Task<bool> MoveToContentAsync(CancellationToken cancellationToken) { JsonToken tokenType = TokenType; if (tokenType == JsonToken.None || tokenType == JsonToken.Comment) { return MoveToContentFromNonContentAsync(cancellationToken); } return AsyncUtils.True; } private async Task<bool> MoveToContentFromNonContentAsync(CancellationToken cancellationToken) { JsonToken tokenType; do { if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false))) { return false; } tokenType = TokenType; } while (tokenType == JsonToken.None || tokenType == JsonToken.Comment); return true; } internal JsonPosition GetPosition(int depth) { if (_stack != null && depth < _stack.Count) { return _stack[depth]; } return _currentPosition; } protected JsonReader() { _currentState = State.Start; _dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind; _dateParseHandling = DateParseHandling.DateTime; _floatParseHandling = FloatParseHandling.Double; _maxDepth = 64; CloseInput = true; } private void Push(JsonContainerType value) { UpdateScopeWithFinishedValue(); if (_currentPosition.Type == JsonContainerType.None) { _currentPosition = new JsonPosition(value); return; } if (_stack == null) { _stack = new List<JsonPosition>(); } _stack.Add(_currentPosition); _currentPosition = new JsonPosition(value); if (!_maxDepth.HasValue || !(Depth + 1 > _maxDepth) || _hasExceededMaxDepth) { return; } _hasExceededMaxDepth = true; throw JsonReaderException.Create(this, "The reader's MaxDepth of {0} has been exceeded.".FormatWith(CultureInfo.InvariantCulture, _maxDepth)); } private JsonContainerType Pop() { JsonPosition currentPosition; if (_stack != null && _stack.Count > 0) { currentPosition = _currentPosition; _currentPosition = _stack[_stack.Count - 1]; _stack.RemoveAt(_stack.Count - 1); } else { currentPosition = _currentPosition; _currentPosition = default(JsonPosition); } if (_maxDepth.HasValue && Depth <= _maxDepth) { _hasExceededMaxDepth = false; } return currentPosition.Type; } private JsonContainerType Peek() { return _currentPosition.Type; } public abstract bool Read(); public virtual int? ReadAsInt32() { JsonToken contentToken = GetContentToken(); switch (contentToken) { case JsonToken.None: case JsonToken.Null: case JsonToken.EndArray: return null; case JsonToken.Integer: case JsonToken.Float: { object value = Value; if (value is int) { return (int)value; } int num; if (value is BigInteger bigInteger) { num = (int)bigInteger; } else { try { num = Convert.ToInt32(value, CultureInfo.InvariantCulture); } catch (Exception ex) { throw JsonReaderException.Create(this, "Could not convert to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex); } } SetToken(JsonToken.Integer, num, updateIndex: false); return num; } case JsonToken.String: { string s = (string)Value; return ReadInt32String(s); } default: throw JsonReaderException.Create(this, "Error reading integer. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken)); } } internal int? ReadInt32String(string? s) { if (StringUtils.IsNullOrEmpty(s)) { SetToken(JsonToken.Null, null, updateIndex: false); return null; } if (int.TryParse(s, NumberStyles.Integer, Culture, out var result)) { SetToken(JsonToken.Integer, result, updateIndex: false); return result; } SetToken(JsonToken.String, s, updateIndex: false); throw JsonReaderException.Create(this, "Could not convert string to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, s)); } public virtual string? ReadAsString() { JsonToken contentToken = GetContentToken(); switch (contentToken) { case JsonToken.None: case JsonToken.Null: case JsonToken.EndArray: return null; case JsonToken.String: return (string)Value; default: if (JsonTokenUtils.IsPrimitiveToken(contentToken)) { object value = Value; if (value != null) { string text = ((!(value is IFormattable formattable)) ? ((value is Uri uri) ? uri.OriginalString : value.ToString()) : formattable.ToString(null, Culture)); SetToken(JsonToken.String, text, updateIndex: false); return text; } } throw JsonReaderException.Create(this, "Error reading string. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken)); } } public virtual byte[]? ReadAsBytes() { JsonToken contentToken = GetContentToken(); switch (contentToken) { case JsonToken.StartObject: { ReadIntoWrappedTypeObject(); byte[] array2 = ReadAsBytes(); ReaderReadAndAssert(); if (TokenType != JsonToken.EndObject) { throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType)); } SetToken(JsonToken.Bytes, array2, updateIndex: false); return array2; } case JsonToken.String: { string text = (string)Value; Guid g; byte[] array3 = ((text.Length == 0) ? CollectionUtils.ArrayEmpty<byte>() : ((!ConvertUtils.TryConvertGuid(text, out g)) ? Convert.FromBase64String(text) : g.ToByteArray())); SetToken(JsonToken.Bytes, array3, updateIndex: false); return array3; } case JsonToken.None: case JsonToken.Null: case JsonToken.EndArray: return null; case JsonToken.Bytes: if (Value is Guid guid) { byte[] array = guid.ToByteArray(); SetToken(JsonToken.Bytes, array, updateIndex: false); return array; } return (byte[])Value; case JsonToken.StartArray: return ReadArrayIntoByteArray(); default: throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken)); } } internal byte[] ReadArrayIntoByteArray() { List<byte> list = new List<byte>(); do { if (!Read()) { SetToken(JsonToken.None); } } while (!ReadArrayElementIntoByteArrayReportDone(list)); byte[] array = list.ToArray(); SetToken(JsonToken.Bytes, array, updateIndex: false); return array; } private bool ReadArrayElementIntoByteArrayReportDone(List<byte> buffer) { switch (TokenType) { case JsonToken.None: throw JsonReaderException.Create(this, "Unexpected end when reading bytes."); case JsonToken.Integer: buffer.Add(Convert.ToByte(Value, CultureInfo.InvariantCulture)); return false; case JsonToken.EndArray: return true; case JsonToken.Comment: return false; default: throw JsonReaderException.Create(this, "Unexpected token when reading bytes: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType)); } } public virtual double? ReadAsDouble() { JsonToken contentToken = GetContentToken(); switch (contentToken) { case JsonToken.None: case JsonToken.Null: case JsonToken.EndArray: return null; case JsonToken.Integer: case JsonToken.Float: { object value = Value; if (value is double) { return (double)value; } double num = ((!(value is BigInteger bigInteger)) ? Convert.ToDouble(value, CultureInfo.InvariantCulture) : ((double)bigInteger)); SetToken(JsonToken.Float, num, updateIndex: false); return num; } case JsonToken.String: return ReadDoubleString((string)Value); default: throw JsonReaderException.Create(this, "Error reading double. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken)); } } internal double? ReadDoubleString(string? s) { if (StringUtils.IsNullOrEmpty(s)) { SetToken(JsonToken.Null, null, updateIndex: false); return null; } if (double.TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, Culture, out var result)) { SetToken(JsonToken.Float, result, updateIndex: false); return result; } SetToken(JsonToken.String, s, updateIndex: false); throw JsonReaderException.Create(this, "Could not convert string to double: {0}.".FormatWith(CultureInfo.InvariantCulture, s)); } public virtual bool? ReadAsBoolean() { JsonToken contentToken = GetContentToken(); switch (contentToken) { case JsonToken.None: case JsonToken.Null: case JsonToken.EndArray: return null; case JsonToken.Integer: case JsonToken.Float: { bool flag = ((!(Value is BigInteger bigInteger)) ? Convert.ToBoolean(Value, CultureInfo.InvariantCulture) : (bigInteger != 0L)); SetToken(JsonToken.Boolean, flag, updateIndex: false); return flag; } case JsonToken.String: return ReadBooleanString((string)Value); case JsonToken.Boolean: return (bool)Value; default: throw JsonReaderException.Create(this, "Error reading boolean. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken)); } } internal bool? ReadBooleanString(string? s) { if (StringUtils.IsNullOrEmpty(s)) { SetToken(JsonToken.Null, null, updateIndex: false); return null; } if (bool.TryParse(s, out var result)) { SetToken(JsonToken.Boolean, result, updateIndex: false); return result; } SetToken(JsonToken.String, s, updateIndex: false); throw JsonReaderException.Create(this, "Could not convert string to boolean: {0}.".FormatWith(CultureInfo.InvariantCulture, s)); } public virtual decimal? ReadAsDecimal() { JsonToken contentToken = GetContentToken(); switch (contentToken) { case JsonToken.None: case JsonToken.Null: case JsonToken.EndArray: return null; case JsonToken.Integer: case JsonToken.Float: { object value = Value; if (value is decimal) { return (decimal)value; } decimal num; if (value is BigInteger bigInteger) { num = (decimal)bigInteger; } else { try { num = Convert.ToDecimal(value, CultureInfo.InvariantCulture); } catch (Exception ex) { throw JsonReaderException.Create(this, "Could not convert to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex); } } SetToken(JsonToken.Float, num, updateIndex: false); return num; } case JsonToken.String: return ReadDecimalString((string)Value); default: throw JsonReaderException.Create(this, "Error reading decimal. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken)); } } internal decimal? ReadDecimalString(string? s) { if (StringUtils.IsNullOrEmpty(s)) { SetToken(JsonToken.Null, null, updateIndex: false); return null; } if (decimal.TryParse(s, NumberStyles.Number, Culture, out var result)) { SetToken(JsonToken.Float, result, updateIndex: false); return result; } if (ConvertUtils.DecimalTryParse(s.ToCharArray(), 0, s.Length, out result) == ParseResult.Success) { SetToken(JsonToken.Float, result, updateIndex: false); return result; } SetToken(JsonToken.String, s, updateIndex: false); throw JsonReaderException.Create(this, "Could not convert string to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, s)); } public virtual DateTime? ReadAsDateTime() { switch (GetContentToken()) { case JsonToken.None: case JsonToken.Null: case JsonToken.EndArray: return null; case JsonToken.Date: if (Value is DateTimeOffset dateTimeOffset) { SetToken(JsonToken.Date, dateTimeOffset.DateTime, updateIndex: false); } return (DateTime)Value; case JsonToken.String: return ReadDateTimeString((string)Value); default: throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType)); } } internal DateTime? ReadDateTimeString(string? s) { if (StringUtils.IsNullOrEmpty(s)) { SetToken(JsonToken.Null, null, updateIndex: false); return null; } if (DateTimeUtils.TryParseDateTime(s, DateTimeZoneHandling, _dateFormatString, Culture, out var dt)) { dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling); SetToken(JsonToken.Date, dt, updateIndex: false); return dt; } if (DateTime.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt)) { dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling); SetToken(JsonToken.Date, dt, updateIndex: false); return dt; } throw JsonReaderException.Create(this, "Could not convert string to DateTime: {0}.".FormatWith(CultureInfo.InvariantCulture, s)); } public virtual DateTimeOffset? ReadAsDateTimeOffset() { JsonToken contentToken = GetContentToken(); switch (contentToken) { case JsonToken.None: case JsonToken.Null: case JsonToken.EndArray: return null; case JsonToken.Date: if (Value is DateTime dateTime) { SetToken(JsonToken.Date, new DateTimeOffset(dateTime), updateIndex: false); } return (DateTimeOffset)Value; case JsonToken.String: { string s = (string)Value; return ReadDateTimeOffsetString(s); } default: throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken)); } } internal DateTimeOffset? ReadDateTimeOffsetString(string? s) { if (StringUtils.IsNullOrEmpty(s)) { SetToken(JsonToken.Null, null, updateIndex: false); return null; } if (DateTimeUtils.TryParseDateTimeOffset(s, _dateFormatString, Culture, out var dt)) { SetToken(JsonToken.Date, dt, updateIndex: false); return dt; } if (DateTimeOffset.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt)) { SetToken(JsonToken.Date, dt, updateIndex: false); return dt; } SetToken(JsonToken.String, s, updateIndex: false); throw JsonReaderException.Create(this, "Could not convert string to DateTimeOffset: {0}.".FormatWith(CultureInfo.InvariantCulture, s)); } internal void ReaderReadAndAssert() { if (!Read()) { throw CreateUnexpectedEndException(); } } internal JsonReaderException CreateUnexpectedEndException() { return JsonReaderException.Create(this, "Unexpected end when reading JSON."); } internal void ReadIntoWrappedTypeObject() { ReaderReadAndAssert(); if (Value != null && Value.ToString() == "$type") { ReaderReadAndAssert(); if (Value != null && Value.ToString().StartsWith("System.Byte[]", StringComparison.Ordinal)) { ReaderReadAndAssert(); if (Value.ToString() == "$value") { return; } } } throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, JsonToken.StartObject)); } public void Skip() { if (TokenType == JsonToken.PropertyName) { Read(); } if (JsonTokenUtils.IsStartToken(TokenType)) { int depth = Depth; while (Read() && depth < Depth) { } } } protected void SetToken(JsonToken newToken) { SetToken(newToken, null, updateIndex: true); } protected void SetToken(JsonToken newToken, object? value) { SetToken(newToken, value, updateIndex: true); } protected void SetToken(JsonToken newToken, object? value, bool updateIndex) { _tokenType = newToken; _value = value; switch (newToken) { case JsonToken.StartObject: _currentState = State.ObjectStart; Push(JsonContainerType.Object); break; case JsonToken.StartArray: _currentState = State.ArrayStart; Push(JsonContainerType.Array); break; case JsonToken.StartConstructor: _currentState = State.ConstructorStart; Push(JsonContainerType.Constructor); break; case JsonToken.EndObject: ValidateEnd(JsonToken.EndObject); break; case JsonToken.EndArray: ValidateEnd(JsonToken.EndArray); break; case JsonToken.EndConstructor: ValidateEnd(JsonToken.EndConstructor); break; case JsonToken.PropertyName: _currentState = State.Property; _currentPosition.PropertyName = (string)value; break; case JsonToken.Raw: case JsonToken.Integer: case JsonToken.Float: case JsonToken.String: case JsonToken.Boolean: case JsonToken.Null: case JsonToken.Undefined: case JsonToken.Date: case JsonToken.Bytes: SetPostValueState(updateIndex); break; case JsonToken.Comment: break; } } internal void SetPostValueState(bool updateIndex) { if (Peek() != 0 || SupportMultipleContent) { _currentState = State.PostValue; } else { SetFinished(); } if (updateIndex) { UpdateScopeWithFinishedValue(); } } private void UpdateScopeWithFinishedValue() { if (_currentPosition.HasIndex) { _currentPosition.Position++; } } private void ValidateEnd(JsonToken endToken) { JsonContainerType jsonContainerType = Pop(); if (GetTypeForCloseToken(endToken) != jsonContainerType) { throw JsonReaderException.Create(this, "JsonToken {0} is not valid for closing JsonType {1}.".FormatWith(CultureInfo.InvariantCulture, endToken, jsonContainerType)); } if (Peek() != 0 || SupportMultipleContent) { _currentState = State.PostValue; } else { SetFinished(); } } protected void SetStateBasedOnCurrent() { JsonContainerType jsonContainerType = Peek(); switch (jsonContainerType) { case JsonContainerType.Object: _currentState = State.Object; break; case JsonContainerType.Array: _currentState = State.Array; break; case JsonContainerType.Constructor: _currentState = State.Constructor; break; case JsonContainerType.None: SetFinished(); break; default: throw JsonReaderException.Create(this, "While setting the reader state back to current object an unexpected JsonType was encountered: {0}".FormatWith(CultureInfo.InvariantCulture, jsonContainerType)); } } private void SetFinished() { _currentState = ((!SupportMultipleContent) ? State.Finished : State.Start); } private JsonContainerType GetTypeForCloseToken(JsonToken token) { return token switch { JsonToken.EndObject => JsonContainerType.Object, JsonToken.EndArray => JsonContainerType.Array, JsonToken.EndConstructor => JsonContainerType.Constructor, _ => throw JsonReaderException.Create(this, "Not a valid close JsonToken: {0}".FormatWith(CultureInfo.InvariantCulture, token)), }; } void IDisposable.Dispose() { Dispose(disposing: true); GC.SuppressFinalize(this); } protected virtual void Dispose(bool disposing) { if (_currentState != State.Closed && disposing) { Close(); } } public virtual void Close() { _currentState = State.Closed; _tokenType = JsonToken.None; _value = null; } internal void ReadAndAssert() { if (!Read()) { throw JsonSerializationException.Create(this, "Unexpected end when reading JSON."); } } internal void ReadForTypeAndAssert(JsonContract? contract, bool hasConverter) { if (!ReadForType(contract, hasConverter)) { throw JsonSerializationException.Create(this, "Unexpected end when reading JSON."); } } internal bool ReadForType(JsonContract? contract, bool hasConverter) { if (hasConverter) { return Read(); } switch (contract?.InternalReadType ?? ReadType.Read) { case ReadType.Read: return ReadAndMoveToContent(); case ReadType.ReadAsInt32: ReadAsInt32(); break; case ReadType.ReadAsInt64: { bool result = ReadAndMoveToContent(); if (TokenType == JsonToken.Undefined) { throw JsonReaderException.Create(this, "An undefined token is not a valid {0}.".FormatWith(CultureInfo.InvariantCulture, contract?.UnderlyingType ?? typeof(long))); } return result; } case ReadType.ReadAsDecimal: ReadAsDecimal(); break; case ReadType.ReadAsDouble: ReadAsDouble(); break; case ReadType.ReadAsBytes: ReadAsBytes(); break; case ReadType.ReadAsBoolean: ReadAsBoolean(); break; case ReadType.ReadAsString: ReadAsString(); break; case ReadType.ReadAsDateTime: ReadAsDateTime(); break; case ReadType.ReadAsDateTimeOffset: ReadAsDateTimeOffset(); break; default: throw new ArgumentOutOfRangeException(); } return TokenType != JsonToken.None; } internal bool ReadAndMoveToContent() { if (Read()) { return MoveToContent(); } return false; } internal bool MoveToContent() { JsonToken tokenType = TokenType; while (tokenType == JsonToken.None || tokenType == JsonToken.Comment) { if (!Read()) { return false; } tokenType = TokenType; } return true; } private JsonToken GetContentToken() { JsonToken tokenType; do { if (!Read()) { SetToken(JsonToken.None); return JsonToken.None; } tokenType = TokenType; } while (tokenType == JsonToken.Comment); return tokenType; } } [Serializable] public class JsonReaderException : JsonException { public int LineNumber { get; } public int LinePosition { get; } public string? Path { get; } public JsonReaderException() { } public JsonReaderException(string message) : base(message) { } public JsonReaderException(string message, Exception innerException) : base(message, innerException) { } public JsonReaderException(SerializationInfo info, StreamingContext context) : base(info, context) { } public JsonReaderException(string message, string path, int lineNumber, int linePosition, Exception? innerException) : base(message, innerException) { Path = path; LineNumber = lineNumber; LinePosition = linePosition; } internal static JsonReaderException Create(JsonReader reader, string message) { return Create(reader, message, null); } internal static JsonReaderException Create(JsonReader reader, string message, Exception? ex) { return Create(reader as IJsonLineInfo, reader.Path, message, ex); } internal static JsonReaderException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex) { message = JsonPosition.FormatMessage(lineInfo, path, message); int lineNumber; int linePosition; if (lineInfo != null && lineInfo.HasLineInfo()) { lineNumber = lineInfo.LineNumber; linePosition = lineInfo.LinePosition; } else { lineNumber = 0; linePosition = 0; } return new JsonReaderException(message, path, lineNumber, linePosition, ex); } } [AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)] public sealed class JsonRequiredAttribute : Attribute { } [Serializable] public class JsonSerializationException : JsonException { public int LineNumber { get; } public int LinePosition { get; } public string? Path { get; } public JsonSerializationException() { } public JsonSerializationException(string message) : base(message) { } public JsonSerializationException(string message, Exception innerException) : base(message, innerException) { } public JsonSerializationException(SerializationInfo info, StreamingContext context) : base(info, context) { } public JsonSerializationException(string message, string path, int lineNumber, int linePosition, Exception? innerException) : base(message, innerException) { Path = path; LineNumber = lineNumber; LinePosition = linePosition; } internal static JsonSerializationException Create(JsonReader reader, string message) { return Create(reader, message, null); } internal static JsonSerializationException Create(JsonReader reader, string message, Exception? ex) { return Create(reader as IJsonLineInfo, reader.Path, message, ex); } internal static JsonSerializationException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex) { message = JsonPosition.FormatMessage(lineInfo, path, message); int lineNumber; int linePosition; if (lineInfo != null && lineInfo.HasLineInfo()) { lineNumber = lineInfo.LineNumber; linePosition = lineInfo.LinePosition; } else { lineNumber = 0; linePosition = 0; } return new JsonSerializationException(message, path, lineNumber, linePosition, ex); } } public class JsonSerializer { internal TypeNameHandling _typeNameHandling; internal TypeNameAssemblyFormatHandling _typeNameAssemblyFormatHandling; internal PreserveReferencesHandling _preserveReferencesHandling; internal ReferenceLoopHandling _referenceLoopHandling; internal MissingMemberHandling _missingMemberHandling; internal ObjectCreationHandling _objectCreationHandling; internal NullValueHandling _nullValueHandling; internal DefaultValueHandling _defaultValueHandling; internal ConstructorHandling _constructorHandling; internal MetadataPropertyHandling _metadataPropertyHandling; internal JsonConverterCollection? _converters; internal IContractResolver _contractResolver; internal ITraceWriter? _traceWriter; internal IEqualityComparer? _equalityComparer; internal ISerializationBinder _serializationBinder; internal StreamingContext _context; private IReferenceResolver? _referenceResolver; private Formatting? _formatting; private DateFormatHandling? _dateFormatHandling; private DateTimeZoneHandling? _dateTimeZoneHandling; private DateParseHandling? _dateParseHandling; private FloatFormatHandling? _floatFormatHandling; private FloatParseHandling? _floatParseHandling; private StringEscapeHandling? _stringEscapeHandling; private CultureInfo _culture; private int? _maxDepth; private bool _maxDepthSet; private bool? _checkAdditionalContent; private string? _dateFormatString; private bool _dateFormatStringSet; public virtual IReferenceResolver? ReferenceResolver { get { return GetReferenceResolver(); } set { if (value == null) { throw new ArgumentNullException("value", "Reference resolver cannot be null."); } _referenceResolver = value; } } [Obsolete("Binder is obsolete. Use SerializationBinder instead.")] public virtual SerializationBinder Binder { get { if (_serializationBinder is SerializationBinder result) { return result; } if (_serializationBinder is SerializationBinderAdapter serializationBinderAdapter) { return serializationBinderAdapter.SerializationBinder; } throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set."); } set { if (value == null) { throw new ArgumentNullException("value", "Serialization binder cannot be null."); } _serializationBinder = (value as ISerializationBinder) ?? new SerializationBinderAdapter(value); } } public virtual ISerializationBinder SerializationBinder { get { return _serializationBinder; } set { if (value == null) { throw new ArgumentNullException("value", "Serialization binder cannot be null."); } _serializationBinder = value; } } public virtual ITraceWriter? TraceWriter { get { return _traceWriter; } set { _traceWriter = value; } } public virtual IEqualityComparer? EqualityComparer { get { return _equalityComparer; } set { _equalityComparer = value; } } public virtual TypeNameHandling TypeNameHandling { get { return _typeNameHandling; } set { if (value < TypeNameHandling.None || value > TypeNameHandling.Auto) { throw new ArgumentOutOfRangeException("value"); } _typeNameHandling = value; } } [Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")] public virtual FormatterAssemblyStyle TypeNameAssemblyFormat { get { return (FormatterAssemblyStyle)_typeNameAssemblyFormatHandling; } set { if (value < FormatterAssemblyStyle.Simple || value > FormatterAssemblyStyle.Full) { throw new ArgumentOutOfRangeException("value"); } _typeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value; } } public virtual TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling { get { return _typeNameAssemblyFormatHandling; } set { if (value < TypeNameAssemblyFormatHandling.Simple || value > TypeNameAssemblyFormatHandling.Full) { throw new ArgumentOutOfRangeException("value"); } _typeNameAssemblyFormatHandling = value; } } public virtual PreserveReferencesHandling PreserveReferencesHandling { get { return _preserveReferencesHandling; } set { if (value < PreserveReferencesHandling.None || value > PreserveReferencesHandling.All) { throw new ArgumentOutOfRangeException("value"); } _preserveReferencesHandling = value; } } public virtual ReferenceLoopHandling ReferenceLoopHandling { get { return _referenceLoopHandling; } set { if (value < ReferenceLoopHandling.Error || value > ReferenceLoopHandling.Serialize) { throw new ArgumentOutOfRangeException("value"); } _referenceLoopHandling = value; } } public virtual MissingMemberHandling MissingMemberHandling { get { return _missingMemberHandling; } set { if (value < MissingMemberHandling.Ignore || value > MissingMemberHandling.Error) { throw new ArgumentOutOfRangeException("value"); } _missingMemberHandling = value; } } public virtual NullValueHandling NullValueHandling { get { return _nullValueHandling; } set { if (value < NullValueHandling.Include || value > NullValueHandling.Ignore) { throw new ArgumentOutOfRangeException("value"); } _nullValueHandling = value; } } public virtual DefaultValueHandling DefaultValueHandling { get { return _defaultValueHandling; } set { if (value < DefaultValueHandling.Include || value > DefaultValueHandling.IgnoreAndPopulate) { throw new ArgumentOutOfRangeException("value"); } _defaultValueHandling = value; } } public virtual ObjectCreationHandling ObjectCreationHandling { get { return _objectCreationHandling; } set { if (value < ObjectCreationHandling.Auto || value > ObjectCreationHandling.Replace) { throw new ArgumentOutOfRangeException("value"); } _objectCreationHandling = value; } } public virtual ConstructorHandling ConstructorHandling { get { return _constructorHandling; } set { if (value < ConstructorHandling.Default || value > ConstructorHandling.AllowNonPublicDefaultConstructor) { throw new ArgumentOutOfRangeException("value"); } _constructorHandling = value; } } public virtual MetadataPropertyHandling MetadataPropertyHandling { get { return _metadataPropertyHandling; } set { if (value < MetadataPropertyHandling.Default || value > MetadataPropertyHandling.Ignore) { throw new ArgumentOutOfRangeException("value"); } _metadataPropertyHandling = value; } } public virtual JsonConverterCollection Converters { get { if (_converters == null) { _converters = new JsonConverterCollection(); } return _converters; } } public virtual IContractResolver ContractResolver { get { return _contractResolver; } set { _contractResolver = value ?? DefaultContractResolver.Instance; } } public virtual StreamingContext Context { get { return _context; } set { _context = value; } } public virtual Formatting Formatting { get { return _formatting.GetValueOrDefault(); } set { _formatting = value; } } public virtual DateFormatHandling DateFormatHandling { get { return _dateFormatHandling.GetValueOrDefault(); } set { _dateFormatHandling = value; } } public virtual DateTimeZoneHandling DateTimeZoneHandling { get { return _dateTimeZoneHandling ?? DateTimeZoneHandling.RoundtripKind; } set { _dateTimeZoneHandling = value; } } public virtual DateParseHandling DateParseHandling { get { return _dateParseHandling ?? DateParseHandling.DateTime; } set { _dateParseHandling = value; } } public virtual FloatParseHandling FloatParseHandling { get { return _floatParseHandling.GetValueOrDefault(); } set { _floatParseHandling = value; } } public virtual FloatFormatHandling FloatFormatHandling { get { return _floatFormatHandling.GetValueOrDefault(); } set { _floatFormatHandling = value; } } public virtual StringEscapeHandling StringEscapeHandling { get { return _stringEscapeHandling.GetValueOrDefault(); } set { _stringEscapeHandling = value; } } public virtual string DateFormatString { get { return _dateFormatString ?? "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK"; } set { _dateFormatString = value; _dateFormatStringSet = true; } } public virtual CultureInfo Culture { get { return _culture ?? JsonSerializerSettings.DefaultCulture; } set { _culture = value; } } public virtual int? MaxDepth { get { return _maxDepth; } set { if (value <= 0) { throw new ArgumentException("Value must be positive.", "value"); } _maxDepth = value; _maxDepthSet = true; } } public virtual bool CheckAdditionalContent { get { return _checkAdditionalContent.GetValueOrDefault(); } set { _checkAdditionalContent = value; } } public virtual event EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs>? Error; internal bool IsCheckAdditionalContentSet() { return _checkAdditionalContent.HasValue; } public JsonSerializer() { _referenceLoopHandling = ReferenceLoopHandling.Error; _missingMemberHandling = MissingMemberHandling.Ignore; _nullValueHandling = NullValueHandling.Include; _defaultValueHandling = DefaultValueHandling.Include; _objectCreationHandling = ObjectCreationHandling.Auto; _preserveReferencesHandling = PreserveReferencesHandling.None; _constructorHandling = ConstructorHandling.Default; _typeNameHandling = TypeNameHandling.None; _metadataPropertyHandling = MetadataPropertyHandling.Default; _context = JsonSerializerSettings.DefaultContext; _serializationBinder = DefaultSerializationBinder.Instance; _culture = JsonSerializerSettings.DefaultCulture; _contractResolver = DefaultContractResolver.Instance; } public static JsonSerializer Create() { return new JsonSerializer(); } public static JsonSerializer Create(JsonSerializerSettings? settings) { JsonSerializer jsonSerializer = Create(); if (settings != null) { ApplySerializerSettings(jsonSerializer, settings); } return jsonSerializer; } public static JsonSerializer CreateDefault() { return Create(JsonConvert.DefaultSettings?.Invoke()); } public static JsonSerializer CreateDefault(JsonSerializerSettings? settings) { JsonSerializer jsonSerializer = CreateDefault(); if (settings != null) { ApplySerializerSettings(jsonSerializer, settings); } return jsonSerializer; } private static void ApplySerializerSettings(JsonSerializer serializer, JsonSerializerSettings settings) { if (!CollectionUtils.IsNullOrEmpty(settings.Converters)) { for (int i = 0; i < settings.Converters.Count; i++) { serializer.Converters.Insert(i, settings.Converters[i]); } } if (settings._typeNameHandling.HasValue) { serializer.TypeNameHandling = settings.TypeNameHandling; } if (settings._metadataPropertyHandling.HasValue) { serializer.MetadataPropertyHandling = settings.MetadataPropertyHandling; } if (settings._typeNameAssemblyFormatHandling.HasValue) { serializer.TypeNameAssemblyFormatHandling = settings.TypeNameAssemblyFormatHandling; } if (settings._preserveReferencesHandling.HasValue) { serializer.PreserveReferencesHandling = settings.PreserveReferencesHandling; } if (settings._referenceLoopHandling.HasValue) { serializer.ReferenceLoopHandling = settings.ReferenceLoopHandling; } if (settings._missingMemberHandling.HasValue) { serializer.MissingMemberHandling = settings.MissingMemberHandling; } if (settings._objectCreationHandling.HasValue) { serializer.ObjectCreationHandling = settings.ObjectCreationHandling; } if (settings._nullValueHandling.HasValue) { serializer.NullValueHandling = settings.NullValueHandling; } if (settings._defaultValueHandling.HasValue) { serializer.DefaultValueHandling = settings.DefaultValueHandling; } if (settings._constructorHandling.HasValue) { serializer.ConstructorHandling = settings.ConstructorHandling; } if (settings._context.HasValue) { serializer.Context = settings.Context; } if (settings._checkAdditionalContent.HasValue) { serializer._checkAdditionalContent = settings._checkAdditionalContent; } if (settings.Error != null) { serializer.Error += settings.Error; } if (settings.ContractResolver != null) { serializer.ContractResolver = settings.ContractResolver; } if (settings.ReferenceResolverProvider != null) { serializer.ReferenceResolver = settings.ReferenceResolverProvider(); } if (settings.TraceWriter != null) { serializer.TraceWriter = settings.TraceWriter; } if (settings.EqualityComparer != null) { serializer.EqualityComparer = settings.EqualityComparer; } if (settings.SerializationBinder != null) { serializer.SerializationBinder = settings.SerializationBinder; } if (settings._formatting.HasValue) { serializer._formatting = settings._formatting; } if (settings._dateFormatHandling.HasValue) { serializer._dateFormatHandling = settings._dateFormatHandling; } if (settings._dateTimeZoneHandling.HasValue) { serializer._dateTimeZoneHandling = settings._dateTimeZoneHandling; } if (settings._dateParseHandling.HasValue) { serializer._dateParseHandling = settings._dateParseHandling; } if (settings._dateFormatStringSet) { serializer._dateFormatString = settings._dateFormatString; serializer._dateFormatStringSet = settings._dateFormatStringSet; } if (settings._floatFormatHandling.HasValue) { serializer._floatFormatHandling = settings._floatFormatHandling; } if (settings._floatParseHandling.HasValue) { serializer._floatParseHandling = settings._floatParseHandling; } if (settings._stringEscapeHandling.HasValue) { serializer._stringEscapeHandling = settings._stringEscapeHandling; } if (settings._culture != null) { serializer._culture = settings._culture; } if (settings._maxDepthSet) { serializer._maxDepth = settings._maxDepth; serializer._maxDepthSet = settings._maxDepthSet; } } [DebuggerStepThrough] public void Populate(TextReader reader, object target) { Populate(new JsonTextReader(reader), target); } [DebuggerStepThrough] public void Populate(JsonReader reader, object target) { PopulateInternal(reader, target); } internal virtual void PopulateInternal(JsonReader reader, object target) { ValidationUtils.ArgumentNotNull(reader, "reader"); ValidationUtils.ArgumentNotNull(target, "target"); SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString); TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null); new JsonSerializerInternalReader(this).Populate(traceJsonReader ?? reader, target); if (traceJsonReader != null) { TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null); } ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString); } [DebuggerStepThrough] public object? Deserialize(JsonReader reader) { return Deserialize(reader, null); } [DebuggerStepThrough] public object? Deserialize(TextReader reader, Type objectType) { return Deserialize(new JsonTextReader(reader), objectType); } [DebuggerStepThrough] public T? Deserialize<T>(JsonReader reader) { return (T)Deserialize(reader, typeof(T)); } [DebuggerStepThrough] public object? Deserialize(JsonReader reader, Type? objectType) { return DeserializeInternal(reader, objectType); } internal virtual object? DeserializeInternal(JsonReader reader, Type? objectType) { ValidationUtils.ArgumentNotNull(reader, "reader"); SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString); TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null); object? result = new JsonSerializerInternalReader(this).Deserialize(traceJsonReader ?? reader, objectType, CheckAdditionalContent); if (traceJsonReader != null) { TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null); } ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString); return result; } internal void SetupReader(JsonReader reader, out CultureInfo? previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string? previousDateFormatString) { if (_culture != null && !_culture.Equals(reader.Culture)) { previousCulture = reader.Culture; reader.Culture = _culture; } else { previousCulture = null; } if (_dateTimeZoneHandling.HasValue && reader.DateTimeZoneHandling != _dateTimeZoneHandling) { previousDateTimeZoneHandling = reader.DateTimeZoneHandling; reader.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault(); } else { previousDateTimeZoneHandling = null; } if (_dateParseHandling.HasValue && reader.DateParseHandling != _dateParseHandling) { previousDateParseHandling = reader.DateParseHandling; reader.DateParseHandling = _dateParseHandling.GetValueOrDefault(); } else { previousDateParseHandling = null; } if (_floatParseHandling.HasValue && reader.FloatParseHandling != _floatParseHandling) { previousFloatParseHandling = reader.FloatParseHandling; reader.FloatParseHandling = _floatParseHandling.GetValueOrDefault(); } else { previousFloatParseHandling = null; } if (_maxDepthSet && reader.MaxDepth != _maxDepth) { previousMaxDepth = reader.MaxDepth; reader.MaxDepth = _maxDepth; } else { previousMaxDepth = null; } if (_dateFormatStringSet && reader.DateFormatString != _dateFormatString) { previousDateFormatString = reader.DateFormatString; reader.DateFormatString = _dateFormatString; } else { previousDateFormatString = null; } if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable == null && _contractResolver is DefaultContractResolver defaultContractResolver) { jsonTextReader.PropertyNameTable = defaultContractResolver.GetNameTable(); } } private void ResetReader(JsonReader reader, CultureInfo? previousCulture, DateTimeZoneHandling? previousDateTimeZoneHandling, DateParseHandling? previousDateParseHandling, FloatParseHandling? previousFloatParseHandling, int? previousMaxDepth, string? previousDateFormatString) { if (previousCulture != null) { reader.Culture = previousCulture; } if (previousDateTimeZoneHandling.HasValue) { reader.DateTimeZoneHandling = previousDateTimeZoneHandling.GetValueOrDefault(); } if (previousDateParseHandling.HasValue) { reader.DateParseHandling = previousDateParseHandling.GetValueOrDefault(); } if (previousFloatParseHandling.HasValue) { reader.FloatParseHandling = previousFloatParseHandling.GetValueOrDefault(); } if (_maxDepthSet) { reader.MaxDepth = previousMaxDepth; } if (_dateFormatStringSet) { reader.DateFormatString = previousDateFormatString; } if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable != null && _contractResolver is DefaultContractResolver defaultContractResolver && jsonTextReader.PropertyNameTable == defaultContractResolver.GetNameTable()) { jsonTextReader.PropertyNameTable = null; } } public void Serialize(TextWriter textWriter, object? value) { Serialize(new JsonTextWriter(textWriter), value); } public void Serialize(JsonWriter jsonWriter, object? value, Type? objectType) { SerializeInternal(jsonWriter, value, objectType); } public void Serialize(TextWriter textWriter, object? value, Type objectType) { Serialize(new JsonTextWriter(textWriter), value, objectType); } public void Serialize(JsonWriter jsonWriter, object? value) { SerializeInternal(jsonWriter, value, null); } private TraceJsonReader CreateTraceJsonReader(JsonReader reader) { TraceJsonReader traceJsonReader = new TraceJsonReader(reader); if (reader.TokenType != 0) { traceJsonReader.WriteCurrentToken(); } return traceJsonReader; } internal virtual void SerializeInternal(JsonWriter jsonWriter, object? value, Type? objectType) { ValidationUtils.ArgumentNotNull(jsonWriter, "jsonWriter"); Formatting? formatting = null; if (_formatting.HasValue && jsonWriter.Formatting != _formatting) { formatting = jsonWriter.Formatting; jsonWriter.Formatting = _formatting.GetValueOrDefault(); } DateFormatHandling? dateFormatHandling = null; if (_dateFormatHandling.HasValue && jsonWriter.DateFormatHandling != _dateFormatHandling) { dateFormatHandling = jsonWriter.DateFormatHandling; jsonWriter.DateFormatHandling = _dateFormatHandling.GetValueOrDefault(); } DateTimeZoneHandling? dateTimeZoneHandling = null; if (_dateTimeZoneHandling.HasValue && jsonWriter.DateTimeZoneHandling != _dateTimeZoneHandling) { dateTimeZoneHandling = jsonWriter.DateTimeZoneHandling; jsonWriter.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault(); } FloatFormatHandling? floatFormatHandling = null; if (_floatFormatHandling.HasValue && jsonWriter.FloatFormatHandling != _floatFormatHandling) { floatFormatHandling = jsonWriter.FloatFormatHandling; jsonWriter.FloatFormatHandling = _floatFormatHandling.GetValueOrDefault(); } StringEscapeHandling? stringEscapeHandling = null; if (_stringEscapeHandling.HasValue && jsonWriter.StringEscapeHandling != _stringEscapeHandling) { stringEscapeHandling = jsonWriter.StringEscapeHandling; jsonWriter.StringEscapeHandling = _stringEscapeHandling.GetValueOrDefault(); } CultureInfo cultureInfo = null; if (_culture != null && !_culture.Equals(jsonWriter.Culture)) { cultureInfo = jsonWriter.Culture; jsonWriter.Culture = _culture; } string dateFormatString = null; if (_dateFormatStringSet && jsonWriter.DateFormatString != _dateFormatString) { dateFormatString = jsonWriter.DateFormatString; jsonWriter.DateFormatString = _dateFormatString; } TraceJsonWriter traceJsonWriter = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? new TraceJsonWriter(jsonWriter) : null); new JsonSerializerInternalWriter(this).Serialize(traceJsonWriter ?? jsonWriter, value, objectType); if (traceJsonWriter != null) { TraceWriter.Trace(TraceLevel.Verbose, traceJsonWriter.GetSerializedJsonMessage(), null); } if (formatting.HasValue) { jsonWriter.Formatting = formatting.GetValueOrDefault(); } if (dateFormatHandling.HasValue) { jsonWriter.DateFormatHandling = dateFormatHandling.GetValueOrDefault(); } if (dateTimeZoneHandling.HasValue) { jsonWriter.DateTimeZoneHandling = dateTimeZoneHandling.GetValueOrDefault(); } if (floatFormatHandling.HasValue) { jsonWriter.FloatFormatHandling = floatFormatHandling.GetValueOrDefault(); } if (stringEscapeHandling.HasValue) { jsonWriter.StringEscapeHandling = stringEscapeHandling.GetValueOrDefault(); } if (_dateFormatStringSet) { jsonWriter.DateFormatString = dateFormatString; } if (cultureInfo != null) { jsonWriter.Culture = cultureInfo; } } internal IReferenceResolver GetReferenceResolver() { if (_referenceResolver == null) { _referenceResolver = new DefaultReferenceResolver(); } return _referenceResolver; } internal JsonConverter? GetMatchingConverter(Type type) { return GetMatchingConverter(_converters, type); } internal static JsonConverter? GetMatchingConverter(IList<JsonConverter>? converters, Type objectType) { if (converters != null) { for (int i = 0; i < converters.Count; i++) { JsonConverter jsonConverter = converters[i]; if (jsonConverter.CanConvert(objectType)) { return jsonConverter; } } } return null; } internal void OnError(Newtonsoft.Json.Serialization.ErrorEventArgs e) { this.Error?.Invoke(this, e); } } public class JsonSerializerSettings { internal const ReferenceLoopHandling DefaultReferenceLoopHandling = ReferenceLoopHandling.Error; internal const MissingMemberHandling DefaultMissingMemberHandling = MissingMemberHandling.Ignore; internal const NullValueHandling DefaultNullValueHandling = NullValueHandling.Include; internal const DefaultValueHandling DefaultDefaultValueHandling = DefaultValueHandling.Include; internal const ObjectCreationHandling DefaultObjectCreationHandling = ObjectCreationHandling.Auto; internal const PreserveReferencesHandling DefaultPreserveReferencesHandling = PreserveReferencesHandling.None; internal const ConstructorHandling DefaultConstructorHandling = ConstructorHandling.Default; internal const TypeNameHandling DefaultTypeNameHandling = TypeNameHandling.None; internal const MetadataPropertyHandling DefaultMetadataPropertyHandling = MetadataPropertyHandling.Default; internal static readonly StreamingContext DefaultContext; internal const Formatting DefaultFormatting = Formatting.None; internal const DateFormatHandling DefaultDateFormatHandling = DateFormatHandling.IsoDateFormat; internal const DateTimeZoneHandling DefaultDateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind; internal const DateParseHandling DefaultDateParseHandling = DateParseHandling.DateTime; internal const FloatParseHandling DefaultFloatParseHandling = FloatParseHandling.Double; internal const FloatFormatHandling DefaultFloatFormatHandling = FloatFormatHandling.String; internal const StringEscapeHandling DefaultStringEscapeHandling = StringEscapeHandling.Default; internal const TypeNameAssemblyFormatHandling DefaultTypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple; internal static readonly CultureInfo DefaultCulture; internal const bool DefaultCheckAdditionalContent = false; internal const string DefaultDateFormatString = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK"; internal const int DefaultMaxDepth = 64; internal Formatting? _formatting; internal DateFormatHandling? _dateFormatHandling; internal DateTimeZoneHandling? _dateTimeZoneHandling; internal DateParseHandling? _dateParseHandling; internal FloatFormatHandling? _floatFormatHandling; internal FloatParseHandling? _floatParseHandling; internal StringEscapeHandling? _stringEscapeHandling; internal CultureInfo? _culture; internal bool? _checkAdditionalContent; internal int? _maxDepth; internal bool _maxDepthSet; internal string? _dateFormatString; internal bool _dateFormatStringSet; internal TypeNameAssemblyFormatHandling? _typeNameAssemblyFormatHandling; internal DefaultValueHandling? _defaultValueHandling; internal PreserveReferencesHandling? _preserveReferencesHandling; internal NullValueHandling? _nullValueHandling; internal ObjectCreationHandling? _objectCreationHandling; internal MissingMemberHandling? _missingMemberHandling; internal ReferenceLoopHandling? _referenceLoopHandling; internal StreamingContext? _context; internal ConstructorHandling? _constructorHandling; internal TypeNameHandling? _typeNameHandling; internal MetadataPropertyHandling? _metadataPropertyHandling; public ReferenceLoopHandling ReferenceLoopHandling { get { return _referenceLoopHandling.GetValueOrDefault(); } set { _referenceLoopHandling = value; } } public MissingMemberHandling MissingMemberHandling { get { return _missingMemberHandling.GetValueOrDefault(); } set { _missingMemberHandling = value; } } public ObjectCreationHandling ObjectCreationHandling { get { return _objectCreationHandling.GetValueOrDefault(); } set { _objectCreationHandling = value; } } public NullValueHandling NullValueHandling { get { return _nullValueHandling.GetValueOrDefault(); } set { _nullValueHandling = value; } } public DefaultValueHandling DefaultValueHandling { get { return _defaultValueHandling.GetValueOrDefault(); } set { _defaultValueHandling = value; } } public IList<JsonConverter> Converters { get; set; } public PreserveReferencesHandling PreserveReferencesHandling { get { return _preserveReferencesHandling.GetValueOrDef
GreyAnnouncer.dll
Decompiled a month agousing System; using System.Collections; using System.Collections.Generic; using System.ComponentModel; using System.Diagnostics; using System.IO; using System.Linq; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using System.Text; using System.Threading.Tasks; using BepInEx; using BepInEx.Bootstrap; using BepInEx.Configuration; using BepInEx.Logging; using HarmonyLib; using Microsoft.CodeAnalysis; using Newtonsoft.Json; using PluginConfig.API; using PluginConfig.API.Decorators; using PluginConfig.API.Fields; using PluginConfig.API.Functionals; using TMPro; using UnityEngine; using UnityEngine.Networking; using greycsont.GreyAnnouncer; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)] [assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")] [assembly: AssemblyCompany("GreyAnnouncer")] [assembly: AssemblyConfiguration("Debug")] [assembly: AssemblyDescription("My first plugin")] [assembly: AssemblyFileVersion("0.0.1.0")] [assembly: AssemblyInformationalVersion("0.0.1")] [assembly: AssemblyProduct("GreyAnnouncer")] [assembly: AssemblyTitle("GreyAnnouncer")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("0.0.1.0")] [module: UnverifiableCode] [module: RefSafetyRules(11)] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] internal sealed class EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)] internal sealed class RefSafetyRulesAttribute : Attribute { public readonly int Version; public RefSafetyRulesAttribute(int P_0) { Version = P_0; } } } public class AudioSourcePool : MonoBehaviour { private Queue<AudioSource> m_pool = new Queue<AudioSource>(); private readonly HashSet<AudioSource> m_activeAudioSources = new HashSet<AudioSource>(); private LinkedList<AudioSource> m_playingList = new LinkedList<AudioSource>(); private Dictionary<AudioSource, LinkedListNode<AudioSource>> m_playingMap = new Dictionary<AudioSource, LinkedListNode<AudioSource>>(); private static AudioSourcePool m_instance; public int initialSize = 2; public int maxSize = 7; public static AudioSourcePool Instance { get { //IL_0016: Unknown result type (might be due to invalid IL or missing references) //IL_001c: Expected O, but got Unknown if ((Object)(object)m_instance == (Object)null) { GameObject val = new GameObject("AudioSourcePool"); Object.DontDestroyOnLoad((Object)(object)val); m_instance = val.AddComponent<AudioSourcePool>(); m_instance.Initialize(); } return m_instance; } } private void Initialize() { for (int i = 0; i < initialSize; i++) { AudioSource item = CreateNewAudioSource(); m_pool.Enqueue(item); } } public void PlayOneShot(AudioClip clip, AudioSourceSetting config) { AudioSource audioSource = Get(); audioSource = AudioSourceManager.ConfigureAudioSource(audioSource, config); audioSource.clip = clip; UnderwaterController_inWater_Instance.CheckIsInWater(); audioSource.Play(); ((MonoBehaviour)this).StartCoroutine(RecycleAfterPlay(audioSource)); } public void AddAudioLowPassFilterToActiveAudioSource() { foreach (AudioSource activeAudioSource in m_activeAudioSources) { if ((Object)(object)activeAudioSource != (Object)null && ((Component)activeAudioSource).gameObject.activeInHierarchy) { AudioSourceManager.AddLowPassFilter(activeAudioSource); } } } public void RemoveAudioLowPassFilterFromActiveAudioSource() { foreach (AudioSource activeAudioSource in m_activeAudioSources) { if ((Object)(object)activeAudioSource != (Object)null && ((Component)activeAudioSource).gameObject.activeInHierarchy) { AudioSourceManager.RemoveLowPassFilter(activeAudioSource); } } } public void UpdateAllActiveSourcesVolume(float targetVolume, float duration = 0.35f) { foreach (AudioSource activeAudioSource in m_activeAudioSources) { if ((Object)(object)activeAudioSource != (Object)null && ((Component)activeAudioSource).gameObject.activeInHierarchy && activeAudioSource.isPlaying) { ((MonoBehaviour)this).StartCoroutine(AudioSourceManager.FadeVolume(activeAudioSource, targetVolume, duration)); } } } private AudioSource Get() { if (m_activeAudioSources.Count >= maxSize && m_playingList.Count > 0) { LinkedListNode<AudioSource> first = m_playingList.First; m_playingList.RemoveFirst(); m_playingMap.Remove(first.Value); LogManager.LogWarning("Max audio sources reached, forcibly recycling the oldest source."); Recycle(first.Value); } AudioSource val = ((m_pool.Count > 0) ? m_pool.Dequeue() : CreateNewAudioSource()); ((Component)val).gameObject.SetActive(true); m_activeAudioSources.Add(val); LinkedListNode<AudioSource> value = m_playingList.AddLast(val); m_playingMap[val] = value; return val; } private AudioSource CreateNewAudioSource() { //IL_0011: Unknown result type (might be due to invalid IL or missing references) //IL_0017: Expected O, but got Unknown LogManager.LogInfo("Create a new Audio Source"); GameObject val = new GameObject("PooledAudioSource"); val.transform.SetParent(((Component)this).transform); AudioSource result = val.AddComponent<AudioSource>(); val.SetActive(false); return result; } private IEnumerator RecycleAfterPlay(AudioSource audioSource) { yield return (object)new WaitForSeconds(audioSource.clip.length); if (m_playingMap.TryGetValue(audioSource, out var node)) { m_playingList.Remove(node); m_playingMap.Remove(audioSource); } Recycle(audioSource); } private void Recycle(AudioSource audioSource) { if (!((Object)(object)audioSource == (Object)null)) { audioSource.Stop(); audioSource.clip = null; ((Component)audioSource).gameObject.SetActive(false); m_activeAudioSources.Remove(audioSource); m_pool.Enqueue(audioSource); } } } public class SoloAudioSource : MonoBehaviour { private AudioSource m_audioSource; private static SoloAudioSource m_instance; public static SoloAudioSource Instance { get { //IL_0016: Unknown result type (might be due to invalid IL or missing references) //IL_001c: Expected O, but got Unknown if ((Object)(object)m_instance == (Object)null) { GameObject val = new GameObject("SoloAudioSource"); Object.DontDestroyOnLoad((Object)(object)val); m_instance = val.AddComponent<SoloAudioSource>(); } return m_instance; } } public void PlayOneShot(AudioClip clip, AudioSourceSetting config) { if ((Object)(object)m_audioSource == (Object)null) { m_audioSource = ((Component)this).gameObject.AddComponent<AudioSource>(); m_audioSource = AudioSourceManager.ConfigureAudioSource(m_audioSource, config); } m_audioSource.clip = clip; UnderwaterController_inWater_Instance.CheckIsInWater(); m_audioSource.Play(); } public void AddAudioLowPassFilter() { m_audioSource = AudioSourceManager.AddLowPassFilter(m_audioSource); } public void RemoveAudioLowPassFilter() { m_audioSource = AudioSourceManager.RemoveLowPassFilter(m_audioSource); } public void UpdateSoloAudioSourceVolume(float targetVolume, float duration = 0.35f) { if ((Object)(object)m_audioSource != (Object)null) { ((MonoBehaviour)this).StartCoroutine(AudioSourceManager.FadeVolume(m_audioSource, targetVolume, duration)); } } } public static class GuidPrefixAdder { public static string AddPrefixToGUID(string rankKey) { return "GreyAnnouncer_" + rankKey.ToUpper(); } public static string RemovePrefixFromGUID(string guid) { if (guid.StartsWith("GreyAnnouncer_")) { return guid.Substring("GreyAnnouncer_".Length); } return guid; } } namespace greycsont.GreyAnnouncer { public class AudioAnnouncer { private AnnouncerJsonSetting m_jsonSetting; private AudioLoader m_audioLoader; private CooldownManager m_cooldownManager; private AudioSourceSetting m_audioSourceConfig; private string[] m_audioCategories; private string m_audioPath; public void Initialize(string[] audioCategories, AnnouncerJsonSetting jsonSetting, string audioPath) { VariableInitialization(audioCategories, jsonSetting, audioPath); ComponentInitialization(); } [Description("Parry balls of Maurice -> Hit Maurice -> AscendingRank() -> Postfix() -> PlaySound() -> CheckPlayValidation(), This error will skip all the function before CheckPlayValidation(), That's why try-catch has implemented in the fucntion")] public void PlayAudioViaCategory(string category) { try { if (ValidateAndLogPlayback(category)) { PlayAudioClip(category); SetCooldown(category, InstanceConfig.individualPlayCooldown.Value); } } catch (Exception ex) { LogPlaybackError(ex); } } public void PlayAudioViaIndex(int index) { PlayAudioViaCategory(m_audioCategories[index]); } public void ReloadAudio(AnnouncerJsonSetting jsonSetting) { m_jsonSetting = jsonSetting; m_audioLoader.UpdateAudioFileNames(m_jsonSetting); m_audioLoader.FindAvailableAudioAsync(); } public void UpdateAudioPath(string newAudioPaths) { m_audioLoader.UpdateAudioPath(newAudioPaths); } public void ResetCooldown() { m_cooldownManager.ResetCooldowns(); } public void ClearAudioClipsCache() { m_audioLoader.ClearCache(); } public void UpdateJsonSetting(AnnouncerJsonSetting jsonSetting) { m_jsonSetting = jsonSetting; m_audioLoader.UpdateAudioFileNames(jsonSetting); } private void VariableInitialization(string[] audioCategories, AnnouncerJsonSetting jsonSetting, string audioPath) { m_jsonSetting = jsonSetting; m_audioPath = audioPath; m_audioCategories = audioCategories; m_audioSourceConfig = new AudioSourceSetting { SpatialBlend = 0f, Priority = 0, Volume = InstanceConfig.audioSourceVolume.Value, Pitch = 1f }; } private void ComponentInitialization() { AudioLoaderInitialization(); CooldownManagerInitialization(); } private void AudioLoaderInitialization() { m_audioLoader = new AudioLoader(m_audioPath, m_audioCategories, m_jsonSetting); m_audioLoader.FindAvailableAudioAsync(); } private void CooldownManagerInitialization() { m_cooldownManager = new CooldownManager(m_audioCategories); } public void SetCooldown(string category, float cooldown) { m_cooldownManager.StartSharedCooldown(InstanceConfig.sharedPlayCooldown.Value); m_cooldownManager.StartIndividualCooldown(category, cooldown); } private bool ValidateAndLogPlayback(string category) { ValidationState playValidationState = GetPlayValidationState(category); if (playValidationState != 0) { LogManager.LogInfo($"PlayValidationState: {category}, {playValidationState}"); return false; } return true; } private void PlayAudioClip(string category) { switch (InstanceConfig.audioLoadingOptions.Value) { case 0: LoadAndPlayAudioClip(category); break; case 1: PlayAudioClipFromAudioClips(category); break; default: LogManager.LogWarning("Invalid play audio options, using the default one"); LoadAndPlayAudioClip(category); break; } } private void PlayAudioClipFromAudioClips(string category) { AudioClip val = null; val = (InstanceConfig.isAudioRandomizationEnabled.Value ? m_audioLoader.GetRandomClipFromAudioClips() : m_audioLoader.GetClipFromCache(category)); if (!((Object)(object)val == (Object)null)) { AudioDispatcher.SendClipToAudioSource(val, m_audioSourceConfig); } } private async Task LoadAndPlayAudioClip(string category) { long currentRequestId = ++AnnouncerManager.playRequestId; AudioClip clip = (InstanceConfig.isAudioRandomizationEnabled.Value ? (await m_audioLoader.GetRandomClipFromAllAvailableFiles()) : (await m_audioLoader.LoadAndGetSingleAudioClipAsync(category))); if (!((Object)(object)clip == (Object)null)) { if (currentRequestId != AnnouncerManager.playRequestId && InstanceConfig.audioPlayOptions.Value == 0) { LogManager.LogInfo("Aborted outdated audio request for: " + category); } else { AudioDispatcher.SendClipToAudioSource(clip, m_audioSourceConfig); } } } private void LogPlaybackError(Exception ex) { LogManager.LogError("An error occurred while playing sound: " + ex.Message); LogManager.LogError(ex.StackTrace); } private ValidationState GetPlayValidationState(string category) { if (m_cooldownManager == null || m_audioLoader == null) { return ValidationState.ComponentsNotInitialized; } if (m_audioLoader.audioCategories == null || !m_audioLoader.audioCategories.Contains(category)) { return ValidationState.InvalidKey; } if (m_cooldownManager.IsIndividualCooldownActive(category)) { return ValidationState.IndividualCooldown; } if (m_cooldownManager.IsSharedCooldownActive()) { return ValidationState.SharedCooldown; } if (!m_jsonSetting.CategoryAudioMap[category].Enabled) { return ValidationState.DisabledByConfig; } return ValidationState.Success; } } public static class AudioClipLoader { public static async Task<AudioClip> LoadAudioClipAsync(string path) { string extension = Path.GetExtension(path).ToLower(); AudioType? unityAudioType = GetUnityAudioType(extension); if (!unityAudioType.HasValue) { LogManager.LogError("Unsupported audio format: 「" + extension + "」 for " + path); return null; } try { LogManager.LogInfo("Started loading audio: " + path); return await LoadWithUnityAsync(path, unityAudioType.Value); } catch (Exception ex) { LogManager.LogError("Error loading " + path + ": " + ex.Message); return null; } } private static async Task<AudioClip> LoadWithUnityAsync(string path, AudioType audioType) { //IL_0019: Unknown result type (might be due to invalid IL or missing references) //IL_001a: Unknown result type (might be due to invalid IL or missing references) string url = new Uri(path).AbsoluteUri; UnityWebRequest www = UnityWebRequestMultimedia.GetAudioClip(url, audioType); try { UnityWebRequestAsyncOperation operation = www.SendWebRequest(); while (!((AsyncOperation)operation).isDone) { await Task.Delay(10); } if ((int)www.result != 1) { LogManager.LogError("UnityRequest Failed to load audio: " + www.error); return null; } AudioClip clip = DownloadHandlerAudioClip.GetContent(www); LogManager.LogInfo("Loaded audio: " + Path.GetFileName(path)); return clip; } finally { ((IDisposable)www)?.Dispose(); } } private static AudioType? GetUnityAudioType(string extension) { if (1 == 0) { } AudioType? result = extension switch { ".wav" => (AudioType)20, ".mp3" => (AudioType)13, ".ogg" => (AudioType)14, ".aiff" => (AudioType)2, ".aif" => (AudioType)2, ".acc" => (AudioType)1, _ => null, }; if (1 == 0) { } return result; } } public class AnnouncerJsonSetting { public Dictionary<string, CategoryAudioSetting> CategoryAudioMap { get; set; } } public class CategoryAudioSetting { public bool Enabled { get; set; } = true; public string DisplayName { get; set; } public List<string> AudioFiles { get; set; } = new List<string>(); } public class AudioLoader { private Dictionary<string, List<AudioClip>> m_audioClips = new Dictionary<string, List<AudioClip>>(); private AnnouncerJsonSetting m_jsonSetting; private string m_audioPath; public static Action<string> OnPluginConfiguratorLogUpdated; public string[] audioCategories { get; private set; } public HashSet<string> categoryFailedLoading { get; private set; } = new HashSet<string>(); [Description("Q : Why do you using whole AnnouncerJsonSetting as input instead only CategoryAudioMap?A : For future, what kinds of future? idk.")] public AudioLoader(string audioPath, string[] audioCategories, AnnouncerJsonSetting jsonSetting) { m_audioPath = audioPath; this.audioCategories = audioCategories; m_jsonSetting = jsonSetting; } public AudioClip GetClipFromCache(string category) { if (categoryFailedLoading.Contains(category)) { return null; } if (!audioCategories.Contains(category)) { return null; } if (!m_audioClips.TryGetValue(category, out var value) || value.Count == 0) { return null; } int index = Random.Range(0, value.Count); return value[index]; } public AudioClip GetRandomClipFromAudioClips() { List<AudioClip> list = (from clip in m_audioClips.SelectMany((KeyValuePair<string, List<AudioClip>> kvp) => kvp.Value) where (Object)(object)clip != (Object)null select clip).ToList(); return list[Random.Range(0, list.Count)]; } public async Task<AudioClip> LoadAndGetSingleAudioClipAsync(string category) { if (!TryGetValidAudioFiles(category, out var validFiles)) { return null; } string selectedPath = validFiles[Random.Range(0, validFiles.Count)]; AudioClip clip = await AudioClipLoader.LoadAudioClipAsync(selectedPath); if ((Object)(object)clip == (Object)null) { LogCategoryFailure(category, "Selected file failed to load"); } return clip; } public async Task<AudioClip> GetRandomClipFromAllAvailableFiles() { List<string> totalValidFiles = new List<string>(); string[] array = audioCategories; foreach (string category in array) { TryGetValidAudioFiles(category, out var validFiles); foreach (string fileName in validFiles) { totalValidFiles.Add(fileName); } validFiles = null; } if (totalValidFiles.Count == 0) { throw new ArgumentOutOfRangeException("114514"); } string selectedPath = totalValidFiles[Random.Range(0, totalValidFiles.Count)]; AudioClip clip = await AudioClipLoader.LoadAudioClipAsync(selectedPath); if ((Object)(object)clip == (Object)null) { LogCategoryFailure(selectedPath, "Selected file failed to load"); } return clip; } public async Task FindAvailableAudioAsync() { if (InstanceConfig.audioLoadingOptions.Value != 0) { ClearCache(); FileSystemUtil.ValidateAndPrepareDirectory(m_audioPath); await LoadAllCategoriesAsync(); LogLoadingResults(); } } public void UpdateAudioPath(string newAudioPath) { if (string.IsNullOrEmpty(newAudioPath)) { LogManager.LogError("Cannot update with empty or null paths"); return; } LogManager.LogInfo("Updating audio paths and reloading audio..."); m_audioPath = newAudioPath; } public void UpdateAudioFileNames(AnnouncerJsonSetting jsonSetting) { m_jsonSetting = jsonSetting; } public void ClearCache() { ClearAudioClipCache(); categoryFailedLoading.Clear(); } private async Task LoadAllCategoriesAsync() { List<Task<(string category, List<AudioClip> clips)>> loadingTasks = new List<Task<(string, List<AudioClip>)>>(); string[] array = audioCategories; foreach (string category in array) { loadingTasks.Add(LoadCategoryAsync(category).ContinueWith((Task<List<AudioClip>> task) => (category, task.Result))); } (string category, List<AudioClip> clips)[] array2 = await Task.WhenAll(loadingTasks); for (int j = 0; j < array2.Length; j++) { var (category2, clips) = array2[j]; if (clips != null && clips.Count > 0) { m_audioClips[category2] = clips; } } } private async Task<List<AudioClip>> LoadCategoryAsync(string category) { if (!TryGetValidAudioFiles(category, out var validFiles)) { return null; } LogManager.LogInfo($"Loading category {category} with {validFiles.Count} files"); IEnumerable<Task<AudioClip>> clipLoadingTasks = validFiles.Select((string path) => AudioClipLoader.LoadAudioClipAsync(path)); new List<AudioClip>(); try { List<AudioClip> loadedClips = (await Task.WhenAll(clipLoadingTasks)).Where((AudioClip c) => (Object)(object)c != (Object)null).ToList(); if (loadedClips.Count > 0) { LogManager.LogInfo($"Successfully loaded {loadedClips.Count}/{validFiles.Count} clips for {category}"); return loadedClips; } LogCategoryFailure(category, "All audio files failed to load"); return null; } catch (Exception ex) { LogCategoryFailure(category, "Exception during loading: " + ex.Message); return null; } } private void ClearAudioClipCache() { foreach (List<AudioClip> value in m_audioClips.Values) { foreach (AudioClip item in value) { if ((Object)(object)item != (Object)null) { Object.Destroy((Object)(object)item); } } } m_audioClips.Clear(); } private void LogCategoryFailure(string category, string reason) { categoryFailedLoading.Add(category); LogManager.LogWarning("Failed to load category 「" + category + "」: " + reason); } private void LogLoadingResults() { LogForPluginConfigurator(); if (categoryFailedLoading.Count == 0) { LogManager.LogInfo("All audio categories successfully loaded"); } else { LogManager.LogWarning("Failed to load audio categories: " + string.Join(", ", categoryFailedLoading)); } } private void LogForPluginConfigurator() { StringBuilder stringBuilder = new StringBuilder(); string[] array = audioCategories; foreach (string text in array) { List<AudioClip> value; int num = (m_audioClips.TryGetValue(text, out value) ? value.Count : 0); CategoryAudioSetting value2; int num2 = (m_jsonSetting.CategoryAudioMap.TryGetValue(text, out value2) ? value2.AudioFiles.Count : 0); stringBuilder.AppendLine($"{text} ({num}/{num2})"); } string obj = stringBuilder.ToString(); OnPluginConfiguratorLogUpdated?.Invoke(obj); } private bool TryGetValidAudioFiles(string category, out List<string> validFiles) { validFiles = null; if (!m_jsonSetting.CategoryAudioMap.TryGetValue(category, out var value) || value.AudioFiles == null || value.AudioFiles.Count == 0) { LogCategoryFailure(category, "No file names configured"); return false; } List<string> audioFiles = value.AudioFiles; validFiles = audioFiles.Select((string name) => PathManager.GetFileWithExtension(m_audioPath, name)).Where(File.Exists).ToList(); if (validFiles.Count == 0) { LogCategoryFailure(category, "No valid files found"); return false; } return true; } } public class CooldownManager { private Dictionary<string, float> m_individualCooldowns = new Dictionary<string, float>(); public CooldownManager(string[] audioCategories) { foreach (string key in audioCategories) { m_individualCooldowns[key] = 0f; } } public bool IsIndividualCooldownActive(string category) { return m_individualCooldowns[category] > 0f; } public bool IsSharedCooldownActive() { return AnnouncerManager.sharedCooldown > 0f; } public void StartIndividualCooldown(string category, float duration) { ((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(CooldownCoroutine(delegate(float value) { m_individualCooldowns[category] = value; }, duration)); } public void StartSharedCooldown(float duration) { ((MonoBehaviour)CoroutineRunner.Instance).StartCoroutine(CooldownCoroutine(delegate(float value) { AnnouncerManager.sharedCooldown = value; }, duration)); } public void ResetCooldowns() { List<string> list = m_individualCooldowns.Keys.ToList(); foreach (string item in list) { m_individualCooldowns[item] = 0f; } } private IEnumerator CooldownCoroutine(Action<float> setCooldown, float initialCooldown) { if (initialCooldown <= 0f) { setCooldown(0f); yield break; } float cooldown = initialCooldown; float waitTime = cooldown * 3f / 4f; float deltaTimeTime = cooldown * 1f / 4f; setCooldown(cooldown); yield return (object)new WaitForSeconds(waitTime); float timePassed = 0f; while (timePassed < deltaTimeTime) { timePassed += Time.deltaTime; cooldown -= Time.deltaTime; setCooldown(cooldown); yield return null; } setCooldown(0f); } } public enum ValidationState { Success, AudioFailedLoading, SharedCooldown, IndividualCooldown, DisabledByConfig, ClipNotFound, ValidationError, ComponentsNotInitialized, InvalidKey } public static class AnnouncerManager { public static Action reloadAnnouncer; public static Action updateAnnouncerPath; public static Action resetCooldown; public static Action clearAudioClipCache; public static float sharedCooldown; public static long playRequestId; public static void ReloadAllAnnouncer() { reloadAnnouncer?.Invoke(); } public static void UpdateAllAnnouncerPaths() { updateAnnouncerPath?.Invoke(); } public static void ResetCooldown() { sharedCooldown = 0f; resetCooldown?.Invoke(); } public static void ClearAudioClipsCache() { clearAudioClipCache?.Invoke(); } } public static class AudioDispatcher { public static void SendClipToAudioSource(AudioClip clip, AudioSourceSetting m_audioSourceConfig) { switch (InstanceConfig.audioPlayOptions.Value) { case 0: SoloAudioSource.Instance.PlayOneShot(clip, m_audioSourceConfig); break; case 1: AudioSourcePool.Instance.PlayOneShot(clip, m_audioSourceConfig); break; default: SoloAudioSource.Instance.PlayOneShot(clip, m_audioSourceConfig); break; } } } public static class AudioSourceManager { public static AudioSource ConfigureAudioSource(AudioSource audioSource, AudioSourceSetting config) { audioSource.spatialBlend = config.SpatialBlend; audioSource.priority = config.Priority; audioSource.volume = ((config.Volume < 1f) ? config.Volume : 1f); audioSource.pitch = config.Pitch; return audioSource; } public static AudioSource AddLowPassFilter(AudioSource audioSource) { if ((Object)(object)audioSource == (Object)null) { return null; } AudioLowPassFilter val = ((Component)audioSource).gameObject.GetComponent<AudioLowPassFilter>() ?? ((Component)audioSource).gameObject.AddComponent<AudioLowPassFilter>(); val.cutoffFrequency = 1000f; val.lowpassResonanceQ = 1f; return audioSource; } public static AudioSource RemoveLowPassFilter(AudioSource audioSource) { if ((Object)(object)audioSource == (Object)null) { return null; } AudioLowPassFilter component = ((Component)audioSource).GetComponent<AudioLowPassFilter>(); if ((Object)(object)component != (Object)null) { Object.Destroy((Object)(object)component); } return audioSource; } public static IEnumerator FadeVolume(AudioSource audioSource, float targetVolume, float duration) { if (!((Object)(object)audioSource == (Object)null)) { float startVolume = audioSource.volume; float timeStep = duration / 5f; float time = 0f; while (time < duration) { audioSource.volume = Mathf.Lerp(startVolume, targetVolume, time / duration); time += timeStep; yield return (object)new WaitForSeconds(timeStep); } audioSource.volume = targetVolume; } } } public struct AudioSourceSetting { public float SpatialBlend { get; set; } public int Priority { get; set; } public float Volume { get; set; } public float Pitch { get; set; } public static AudioSourceSetting Default { get { AudioSourceSetting result = default(AudioSourceSetting); result.SpatialBlend = 0f; result.Priority = 0; result.Volume = 1f; result.Pitch = 1f; return result; } } } [Description("Because it's..... related so I just put it at here instead of creating a new object file")] public static class UnderwaterController_inWater_Instance { public static bool isInWater { get { UnderwaterController instance = MonoSingleton<UnderwaterController>.Instance; return (Object)(object)instance != (Object)null && instance.inWater; } } public static void CheckIsInWater() { if (!isInWater || !InstanceConfig.isLowPassFilterEnabled.Value) { RemoveAudioLowPassFilterFromAllAudioSource(); } else if (isInWater) { AddAudioLowPassFilterToAllAudioSource(); } } private static void RemoveAudioLowPassFilterFromAllAudioSource() { AudioSourcePool.Instance.RemoveAudioLowPassFilterFromActiveAudioSource(); SoloAudioSource.Instance.RemoveAudioLowPassFilter(); } private static void AddAudioLowPassFilterToAllAudioSource() { AudioSourcePool.Instance.AddAudioLowPassFilterToActiveAudioSource(); SoloAudioSource.Instance.AddAudioLowPassFilter(); } } [Description("Q : Why? A : Prevent when audio is playing and enter/out of the water")] [HarmonyPatch(typeof(UnderwaterController), "EnterWater")] public static class EnterWater_Patch { public static void Postfix() { UnderwaterController_inWater_Instance.CheckIsInWater(); } } [HarmonyPatch(typeof(UnderwaterController), "OutWater")] public static class OutWater_Patch { public static void Postfix() { UnderwaterController_inWater_Instance.CheckIsInWater(); } } public class CoroutineRunner : MonoBehaviour { private static CoroutineRunner m_instance; public static CoroutineRunner Instance { get { //IL_0016: Unknown result type (might be due to invalid IL or missing references) //IL_001c: Expected O, but got Unknown if ((Object)(object)m_instance == (Object)null) { GameObject val = new GameObject("CoroutineRunner"); m_instance = val.AddComponent<CoroutineRunner>(); Object.DontDestroyOnLoad((Object)(object)val); } return m_instance; } } } public static class FileSystemUtil { public static void ValidateAndPrepareDirectory(string directoryPath) { if (!Directory.Exists(directoryPath)) { LogManager.LogWarning("Directory not found: " + directoryPath); Directory.CreateDirectory(directoryPath); } } } public static class JsonManager { public static T ReadJson<T>(string jsonName) where T : class { ValidateJsonName(jsonName); string currentPluginPath = PathManager.GetCurrentPluginPath(jsonName); ValidateFileExists(currentPluginPath, jsonName); return DeserializeJson<T>(currentPluginPath, jsonName); } public static T CreateJson<T>(string jsonName, T data) where T : class { ValidateJsonName(jsonName); string currentPluginPath = PathManager.GetCurrentPluginPath(jsonName); ValidateFileDoesNotExist(currentPluginPath, jsonName); return SerializeAndSaveJson(currentPluginPath, jsonName, data); } public static T WriteJson<T>(string jsonName, T data) where T : class { ValidateJsonName(jsonName); string currentPluginPath = PathManager.GetCurrentPluginPath(jsonName); ValidateFileExists(currentPluginPath, jsonName); return SerializeAndSaveJson(currentPluginPath, jsonName, data); } private static void ValidateJsonName(string jsonName) { if (string.IsNullOrEmpty(jsonName)) { throw new ArgumentException("JSON file name cannot be null or empty"); } } private static void ValidateFileExists(string path, string name) { if (!File.Exists(path)) { throw new FileNotFoundException("JSON file '" + name + "' not found at path: " + path); } } private static void ValidateFileDoesNotExist(string path, string name) { if (File.Exists(path)) { throw new InvalidOperationException("JSON file '" + name + "' already exists at path: " + path); } } private static T DeserializeJson<T>(string path, string name) where T : class { try { string text = File.ReadAllText(path); T val = JsonConvert.DeserializeObject<T>(text); if (val == null) { throw new InvalidOperationException("Failed to deserialize JSON file '" + name + "' into type " + typeof(T).Name); } return val; } catch (Exception ex) { LogManager.LogError("Error reading JSON file '" + name + "': " + ex.Message); throw; } } private static T SerializeAndSaveJson<T>(string path, string name, T data) where T : class { try { string contents = JsonConvert.SerializeObject((object)data, (Formatting)1); File.WriteAllText(path, contents); LogManager.LogInfo("Writed JSON file '" + name + "' at path: " + path); return data; } catch (Exception ex) { LogManager.LogError("Error writing JSON file '" + name + "': " + ex.Message); throw; } } } public static class LogManager { public static void LogInfo(object data) { Plugin.log.LogInfo(data); } public static void LogWarning(object data) { Plugin.log.LogWarning(data); } public static void LogError(object data) { Plugin.log.LogError(data); } } public static class PathManager { public static string GetCurrentPluginPath(string filePath = null) { string directoryName = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location); return CleanPath(Path.Combine(directoryName, filePath ?? string.Empty)); } public static string GetGamePath(string filePath) { string gameRootPath = Paths.GameRootPath; return CleanPath(Path.Combine(gameRootPath, filePath)); } [Description("Reference : (因win程序员想偷懒! 竟在剪切板插入隐藏字符) https://www.bilibili.com/video/BV1ebLczjEWZ (Accessed in 24/4/2025)")] public static string CleanPath(string path) { if (string.IsNullOrEmpty(path)) { return path; } char[] trimChars = new char[5] { '\u202a', '\u202b', '\u202c', '\u202d', '\u202e' }; string text = path.TrimStart(trimChars); if (!path.Equals(text)) { LogManager.LogInfo("Path cleaned: Original='" + path + "', Cleaned='" + text + "'"); } return text; } [Description("Reference : (C# 判断操作系统是 Windows 还是 Linux - 青叶煮酒 - 博客园, 11/1/2022) https://www.cnblogs.com/dhqy/p/15787463.html (Accessed in 25/4/2025)")] public static void OpenDirectory(string path) { if (!string.IsNullOrEmpty(path) && Directory.Exists(path)) { if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { Process.Start("explorer.exe", path); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) { Process.Start("xdg-open", path); } else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { Process.Start("open", path); } else { LogManager.LogWarning("Unsupported OS platform."); } } else { LogManager.LogWarning("The path is not valid or the directory does not exist."); } } public static string GetFileWithExtension(string filePath, string fileName) { string searchPattern = fileName + ".*"; string[] files = Directory.GetFiles(filePath, searchPattern); if (files.Length != 0) { return files[0]; } return null; } } public static class ReflectionManager { public static void LoadByReflection(string assemblyName, string methodName, object[] parameter = null) { try { Assembly executingAssembly = Assembly.GetExecutingAssembly(); Type type = executingAssembly.GetType(assemblyName); type.GetMethod(methodName, BindingFlags.Static | BindingFlags.Public)?.Invoke(null, parameter); } catch (Exception arg) { LogManager.LogError($"Failed to load {assemblyName}'s {methodName} by : {arg}"); } } } [BepInPlugin("greycsont.ultrakill.GreyAnnouncer", "Grey Announcer", "1.1.0")] [BepInProcess("ULTRAKILL.exe")] [BepInDependency(/*Could not decode attribute arguments.*/)] public class Plugin : BaseUnityPlugin { internal static ManualLogSource log; private Harmony m_harmony; private void Awake() { log = ((BaseUnityPlugin)this).Logger; LoadMainModule(); LoadOptionalModule(); PatchHarmony(); LogManager.LogInfo("Plugin greycsont.ultrakill.GreyAnnouncer is loaded!"); } private void LoadMainModule() { InstanceConfig.Initialize(this); } private void LoadOptionalModule() { CheckPluginLoaded("com.eternalUnion.pluginConfigurator", "greycsont.GreyAnnouncer.PluginConfiguratorEntry"); RankAnnouncerV2.Initialize(); } private void PatchHarmony() { //IL_0007: Unknown result type (might be due to invalid IL or missing references) //IL_0011: Expected O, but got Unknown m_harmony = new Harmony("greycsont.ultrakill.GreyAnnouncer.harmony"); m_harmony.PatchAll(); } private void CheckPluginLoaded(string GUID, string assemblyName) { PluginDependencies.LoadIfPluginExists("com.eternalUnion.pluginConfigurator", "PluginConfiguratorEntry", delegate { ReflectionManager.LoadByReflection("greycsont.GreyAnnouncer.PluginConfiguratorEntry", "Initialize"); }); } } public static class MainPanelBuilder { private enum PlayOptions { Override, Parallel } private enum audioLoadingOptions { Load_then_Play, Preload_and_Play } [Serializable] [CompilerGenerated] private sealed class <>c { public static readonly <>c <>9 = new <>c(); public static FloatValueChangeEventDelegate <>9__8_0; public static FloatValueChangeEventDelegate <>9__8_1; public static OnValueChangeEventDelegate <>9__9_0; public static EnumValueChangeEventDelegate<PlayOptions> <>9__9_1; public static EnumValueChangeEventDelegate<audioLoadingOptions> <>9__9_2; public static OnClick <>9__9_3; public static OnClick <>9__9_4; public static OnClick <>9__9_5; public static StringValueChangeEventDelegate <>9__10_0; public static BoolValueChangeEventDelegate <>9__10_1; public static BoolValueChangeEventDelegate <>9__10_2; public static Action<string> <>9__12_0; internal void <CreateCooldownControls>b__8_0(FloatValueChangeEvent e) { InstanceConfig.sharedPlayCooldown.Value = e.value; AnnouncerManager.ResetCooldown(); } internal void <CreateCooldownControls>b__8_1(FloatValueChangeEvent e) { InstanceConfig.individualPlayCooldown.Value = e.value; AnnouncerManager.ResetCooldown(); } internal void <CreateAudioControls>b__9_0(FloatSliderValueChangeEvent e) { InstanceConfig.audioSourceVolume.Value = e.newValue; AudioSourcePool.Instance.UpdateAllActiveSourcesVolume(e.newValue); SoloAudioSource.Instance.UpdateSoloAudioSourceVolume(e.newValue); } internal void <CreateAudioControls>b__9_1(EnumValueChangeEvent<PlayOptions> e) { InstanceConfig.audioPlayOptions.Value = (int)e.value; } internal void <CreateAudioControls>b__9_2(EnumValueChangeEvent<audioLoadingOptions> e) { InstanceConfig.audioLoadingOptions.Value = (int)e.value; if (e.value.Equals(audioLoadingOptions.Load_then_Play)) { LogManager.LogInfo("Clear audio clip cache"); ClearAudioClipsCache(); } if (e.value.Equals(audioLoadingOptions.Preload_and_Play)) { LogManager.LogInfo("Reloading all announcer audio"); ReloadAllAnnouncers(); } } internal void <CreateAudioControls>b__9_3() { PathManager.OpenDirectory(InstanceConfig.audioFolderPath.Value); } internal void <CreateAudioControls>b__9_4() { ReloadAllAnnouncers(); } internal void <CreateAudioControls>b__9_5() { advancedPanel.OpenPanel(); } internal void <CreateAdvancedOptionPanel>b__10_0(StringValueChangeEvent e) { InstanceConfig.audioFolderPath.Value = e.value; AnnouncerManager.UpdateAllAnnouncerPaths(); } internal void <CreateAdvancedOptionPanel>b__10_1(BoolValueChangeEvent e) { InstanceConfig.isLowPassFilterEnabled.Value = e.value; UnderwaterController_inWater_Instance.CheckIsInWater(); } internal void <CreateAdvancedOptionPanel>b__10_2(BoolValueChangeEvent e) { InstanceConfig.isAudioRandomizationEnabled.Value = e.value; LogManager.LogInfo($"Switch audio randomization : {e.value}"); } internal void <CreateDelegateTextFromBackEnd>b__12_0(string log) { logHeader.text = log + "\n"; } } private static readonly Color m_greyColour = new Color(0.85f, 0.85f, 0.85f, 1f); private static readonly Color m_CyanColour = new Color(0f, 1f, 1f, 1f); private static readonly Color m_OrangeColour = new Color(1f, 0.6f, 0.2f, 1f); private static PluginConfigurator m_pluginConfigurator; public static ConfigHeader logHeader; private static ConfigPanel advancedPanel; public static void Build(PluginConfigurator config) { m_pluginConfigurator = config; CreateMainSettingSectionTitle(); CreateCooldownControls(); CreateAudioControls(); CreateAdvancedOptionPanel(); CreateAnnouncerSection(); CreateDelegateTextFromBackEnd(); } private static void CreateMainSettingSectionTitle() { //IL_0010: 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: Expected O, but got Unknown //IL_002e: Unknown result type (might be due to invalid IL or missing references) new ConfigSpace(m_pluginConfigurator.rootPanel, 15f); ConfigHeader val = new ConfigHeader(m_pluginConfigurator.rootPanel, "Main Settings", 24); val.textColor = m_CyanColour; } private static void CreateCooldownControls() { //IL_0029: Unknown result type (might be due to invalid IL or missing references) //IL_002f: Expected O, but got Unknown //IL_0088: Unknown result type (might be due to invalid IL or missing references) //IL_008e: Expected O, but got Unknown //IL_004f: 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) //IL_005a: Expected O, but got Unknown //IL_00ae: Unknown result type (might be due to invalid IL or missing references) //IL_00b3: Unknown result type (might be due to invalid IL or missing references) //IL_00b9: Expected O, but got Unknown FloatField val = new FloatField(m_pluginConfigurator.rootPanel, "Shared Cooldown", "sharedPlayCooldown", InstanceConfig.sharedPlayCooldown.Value, 0f, 114514f); val.defaultValue = InstanceConfig.DEFAULT_SHARED_PLAY_COOLDOWN; object obj = <>c.<>9__8_0; if (obj == null) { FloatValueChangeEventDelegate val2 = delegate(FloatValueChangeEvent e) { InstanceConfig.sharedPlayCooldown.Value = e.value; AnnouncerManager.ResetCooldown(); }; <>c.<>9__8_0 = val2; obj = (object)val2; } val.onValueChange += (FloatValueChangeEventDelegate)obj; FloatField val3 = new FloatField(m_pluginConfigurator.rootPanel, "Individual Cooldown", "individualPlaycooldown", InstanceConfig.individualPlayCooldown.Value, 0f, 1113f); val3.defaultValue = InstanceConfig.DEFAULT_INDIVIDUAL_PLAY_COOLDOWN; object obj2 = <>c.<>9__8_1; if (obj2 == null) { FloatValueChangeEventDelegate val4 = delegate(FloatValueChangeEvent e) { InstanceConfig.individualPlayCooldown.Value = e.value; AnnouncerManager.ResetCooldown(); }; <>c.<>9__8_1 = val4; obj2 = (object)val4; } val3.onValueChange += (FloatValueChangeEventDelegate)obj2; } private static void CreateAudioControls() { //IL_002f: Unknown result type (might be due to invalid IL or missing references) //IL_0035: Expected O, but got Unknown //IL_0055: Unknown result type (might be due to invalid IL or missing references) //IL_005a: Unknown result type (might be due to invalid IL or missing references) //IL_0060: Expected O, but got Unknown //IL_0154: Unknown result type (might be due to invalid IL or missing references) //IL_015a: Expected O, but got Unknown //IL_0175: 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) //IL_0180: Expected O, but got Unknown //IL_01a1: Unknown result type (might be due to invalid IL or missing references) //IL_01a6: Unknown result type (might be due to invalid IL or missing references) //IL_01ac: Expected O, but got Unknown //IL_01cd: Unknown result type (might be due to invalid IL or missing references) //IL_01d2: Unknown result type (might be due to invalid IL or missing references) //IL_01d8: Expected O, but got Unknown FloatSliderField val = new FloatSliderField(m_pluginConfigurator.rootPanel, "Audio Volume", "Audio_Volume", Tuple.Create(0f, 1f), InstanceConfig.audioSourceVolume.Value, 2); val.defaultValue = InstanceConfig.DEFAULT_AUDIO_SOURCE_VOLUME; object obj = <>c.<>9__9_0; if (obj == null) { OnValueChangeEventDelegate val2 = delegate(FloatSliderValueChangeEvent e) { InstanceConfig.audioSourceVolume.Value = e.newValue; AudioSourcePool.Instance.UpdateAllActiveSourcesVolume(e.newValue); SoloAudioSource.Instance.UpdateSoloAudioSourceVolume(e.newValue); }; <>c.<>9__9_0 = val2; obj = (object)val2; } val.onValueChange += (OnValueChangeEventDelegate)obj; EnumField<PlayOptions> val3 = new EnumField<PlayOptions>(m_pluginConfigurator.rootPanel, "Audio Play Option", "Audio_Play_Option", (PlayOptions)InstanceConfig.audioPlayOptions.Value); val3.defaultValue = (PlayOptions)InstanceConfig.DEFAULT_AUDIO_PLAY_OPTIONS; val3.onValueChange += delegate(EnumValueChangeEvent<PlayOptions> e) { InstanceConfig.audioPlayOptions.Value = (int)e.value; }; EnumField<audioLoadingOptions> val4 = new EnumField<audioLoadingOptions>(m_pluginConfigurator.rootPanel, "Audio Loading Option", "Audio_Loading_Option", (audioLoadingOptions)InstanceConfig.audioLoadingOptions.Value); val4.defaultValue = (audioLoadingOptions)InstanceConfig.DEFAULT_AUDIO_LOADING_OPTIONS; val4.onValueChange += delegate(EnumValueChangeEvent<audioLoadingOptions> e) { InstanceConfig.audioLoadingOptions.Value = (int)e.value; if (e.value.Equals(audioLoadingOptions.Load_then_Play)) { LogManager.LogInfo("Clear audio clip cache"); ClearAudioClipsCache(); } if (e.value.Equals(audioLoadingOptions.Preload_and_Play)) { LogManager.LogInfo("Reloading all announcer audio"); ReloadAllAnnouncers(); } }; ButtonArrayField val5 = new ButtonArrayField(m_pluginConfigurator.rootPanel, "audio_button_array", 3, new float[3] { 0.4f, 0.4f, 0.2f }, new string[3] { "Open Audio Folder", "Reload", "Advance" }, 5f); ButtonClickEvent obj2 = val5.OnClickEventHandler(0); object obj3 = <>c.<>9__9_3; if (obj3 == null) { OnClick val6 = delegate { PathManager.OpenDirectory(InstanceConfig.audioFolderPath.Value); }; <>c.<>9__9_3 = val6; obj3 = (object)val6; } obj2.onClick += (OnClick)obj3; ButtonClickEvent obj4 = val5.OnClickEventHandler(1); object obj5 = <>c.<>9__9_4; if (obj5 == null) { OnClick val7 = delegate { ReloadAllAnnouncers(); }; <>c.<>9__9_4 = val7; obj5 = (object)val7; } obj4.onClick += (OnClick)obj5; ButtonClickEvent obj6 = val5.OnClickEventHandler(2); object obj7 = <>c.<>9__9_5; if (obj7 == null) { OnClick val8 = delegate { advancedPanel.OpenPanel(); }; <>c.<>9__9_5 = val8; obj7 = (object)val8; } obj6.onClick += (OnClick)obj7; } private static void CreateAdvancedOptionPanel() { //IL_0015: Unknown result type (might be due to invalid IL or missing references) //IL_001f: Expected O, but got Unknown //IL_0035: 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) //IL_005a: Expected O, but got Unknown //IL_00a4: Unknown result type (might be due to invalid IL or missing references) //IL_00aa: Expected O, but got Unknown //IL_007a: Unknown result type (might be due to invalid IL or missing references) //IL_007f: Unknown result type (might be due to invalid IL or missing references) //IL_0085: Expected O, but got Unknown //IL_00f0: Unknown result type (might be due to invalid IL or missing references) //IL_00f6: Expected O, but got Unknown //IL_00c6: Unknown result type (might be due to invalid IL or missing references) //IL_00cb: Unknown result type (might be due to invalid IL or missing references) //IL_00d1: Expected O, but got Unknown //IL_0112: 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_011d: Expected O, but got Unknown advancedPanel = new ConfigPanel(m_pluginConfigurator.rootPanel, "Advanced Option", "Advanced_Option"); ((ConfigField)advancedPanel).hidden = true; new ConfigSpace(advancedPanel, 15f); StringField val = new StringField(advancedPanel, "Audio Folder Path", "Audio_Folder_Path", InstanceConfig.audioFolderPath.Value); val.defaultValue = InstanceConfig.DEFAULT_AUDIO_FOLDER_PATH; object obj = <>c.<>9__10_0; if (obj == null) { StringValueChangeEventDelegate val2 = delegate(StringValueChangeEvent e) { InstanceConfig.audioFolderPath.Value = e.value; AnnouncerManager.UpdateAllAnnouncerPaths(); }; <>c.<>9__10_0 = val2; obj = (object)val2; } val.onValueChange += (StringValueChangeEventDelegate)obj; BoolField val3 = new BoolField(advancedPanel, "Muffle When Under Water", "LowPassFilter_Enabled", InstanceConfig.isLowPassFilterEnabled.Value); val3.defaultValue = true; object obj2 = <>c.<>9__10_1; if (obj2 == null) { BoolValueChangeEventDelegate val4 = delegate(BoolValueChangeEvent e) { InstanceConfig.isLowPassFilterEnabled.Value = e.value; UnderwaterController_inWater_Instance.CheckIsInWater(); }; <>c.<>9__10_1 = val4; obj2 = (object)val4; } val3.onValueChange += (BoolValueChangeEventDelegate)obj2; BoolField val5 = new BoolField(advancedPanel, "Audio Randomlization", "Audio_Randomlization", InstanceConfig.isAudioRandomizationEnabled.Value); val5.defaultValue = false; object obj3 = <>c.<>9__10_2; if (obj3 == null) { BoolValueChangeEventDelegate val6 = delegate(BoolValueChangeEvent e) { InstanceConfig.isAudioRandomizationEnabled.Value = e.value; LogManager.LogInfo($"Switch audio randomization : {e.value}"); }; <>c.<>9__10_2 = val6; obj3 = (object)val6; } val5.onValueChange += (BoolValueChangeEventDelegate)obj3; } private static void CreateAnnouncerSection() { //IL_0010: 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: Expected O, but got Unknown //IL_002e: Unknown result type (might be due to invalid IL or missing references) //IL_004a: Unknown result type (might be due to invalid IL or missing references) //IL_0054: Expected O, but got Unknown //IL_0076: Unknown result type (might be due to invalid IL or missing references) new ConfigSpace(m_pluginConfigurator.rootPanel, 15f); ConfigHeader val = new ConfigHeader(m_pluginConfigurator.rootPanel, "Announcer Section", 24); val.textColor = m_OrangeColour; logHeader = new ConfigHeader(m_pluginConfigurator.rootPanel, "", 24); logHeader.tmpAnchor = (TextAlignmentOptions)257; logHeader.textSize = 12; logHeader.textColor = m_CyanColour; } private static void CreateDelegateTextFromBackEnd() { AudioLoader.OnPluginConfiguratorLogUpdated = delegate(string log) { logHeader.text = log + "\n"; }; } private static void ReloadAllAnnouncers() { logHeader.text = string.Empty; AnnouncerManager.ReloadAllAnnouncer(); } private static void ClearAudioClipsCache() { logHeader.text = string.Empty; AnnouncerManager.ClearAudioClipsCache(); } } [Description("This object is loaded via reflection from Plugin.cs")] public class PluginConfiguratorEntry { private static PluginConfigurator m_config; public static PluginConfigurator config { get { return m_config; } private set { m_config = value; } } public static void Initialize() { CreatePluginPages(); MainPanelBuilder.Build(m_config); } private static void CreatePluginPages() { m_config = PluginConfigurator.Create("Grey Announcer", "greycsont.ultrakill.GreyAnnouncer"); m_config.SetIconWithURL(PathManager.GetCurrentPluginPath("icon.png")); } } internal static class PluginDependencies { public const string PLUGINCONFIGURATOR_GUID = "com.eternalUnion.pluginConfigurator"; public static void LoadIfPluginExists(string guid, string moduleName, Action loader) { if (!Chainloader.PluginInfos.ContainsKey(guid)) { LogManager.LogWarning("Plugin " + guid + " not loaded, skipping " + moduleName); return; } try { loader?.Invoke(); LogManager.LogInfo("Loaded optional module: " + moduleName); } catch (Exception ex) { LogManager.LogError("Exception while loading " + moduleName + ": " + ex.Message); } } } internal static class PluginInfo { public const string PLUGIN_GUID = "greycsont.ultrakill.GreyAnnouncer"; public const string PLUGIN_NAME = "Grey Announcer"; public const string PLUGIN_VERSION = "1.1.0"; } public static class RankAnnouncerV2 { private static readonly string[] m_rankCategory = new string[8] { "D", "C", "B", "A", "S", "SS", "SSS", "U" }; private static readonly Dictionary<string, string> m_displayNameMapping = new Dictionary<string, string> { { "D", "Destruction" }, { "C", "Chaotic" }, { "B", "Brutal" }, { "A", "Anarchic" }, { "S", "Supreme" }, { "SS", "SSadistic" }, { "SSS", "SSShitstorm" }, { "U", "ULTRAKILL" } }; private static readonly AudioAnnouncer m_announcer = new AudioAnnouncer(); private static readonly string m_jsonName = "RankAnnouncer.json"; private static readonly string m_pageTitle = "Rank Announcer"; internal static AnnouncerJsonSetting m_jsonSetting; public static void Initialize() { JsonInitialization(); m_announcer.Initialize(m_rankCategory, m_jsonSetting, InstanceConfig.audioFolderPath.Value); SubscribeAnnouncerManager(); PluginConfigPanelInitialization(m_pageTitle, m_jsonSetting); } public static void PlayRankSound(int rank) { if (rank < 0 || rank >= m_rankCategory.Length) { LogManager.LogError($"Invalid rank index: {rank}"); } else { m_announcer.PlayAudioViaIndex(rank); } } private static void SubscribeAnnouncerManager() { AnnouncerManager.reloadAnnouncer = (Action)Delegate.Combine(AnnouncerManager.reloadAnnouncer, new Action(ReloadAnnouncer)); AnnouncerManager.resetCooldown = (Action)Delegate.Combine(AnnouncerManager.resetCooldown, new Action(ResetCooldowns)); AnnouncerManager.clearAudioClipCache = (Action)Delegate.Combine(AnnouncerManager.clearAudioClipCache, new Action(ClearAudioClipCache)); AnnouncerManager.updateAnnouncerPath = (Action)Delegate.Combine(AnnouncerManager.updateAnnouncerPath, new Action(UpdateAudioPath)); } private static void ReloadAnnouncer() { JsonInitialization(); UpdateAnnouncerJson(); m_announcer.ReloadAudio(m_jsonSetting); } private static void UpdateAudioPath() { m_announcer.UpdateAudioPath(InstanceConfig.audioFolderPath.Value); } private static void ResetCooldowns() { m_announcer.ResetCooldown(); } private static void ClearAudioClipCache() { m_announcer.ClearAudioClipsCache(); } private static void JsonInitialization() { if (!CheckDoesJsonExists()) { CreateJson(); } m_jsonSetting = JsonManager.ReadJson<AnnouncerJsonSetting>(m_jsonName); } private static bool CheckDoesJsonExists() { return File.Exists(PathManager.GetCurrentPluginPath(m_jsonName)); } private static void CreateJson() { string value; Dictionary<string, CategoryAudioSetting> categoryAudioMap = m_rankCategory.ToDictionary((string cat) => cat, (string cat) => new CategoryAudioSetting { Enabled = true, DisplayName = (m_displayNameMapping.TryGetValue(cat, out value) ? value : cat), AudioFiles = new List<string> { cat } }); m_jsonSetting = new AnnouncerJsonSetting { CategoryAudioMap = categoryAudioMap }; JsonManager.CreateJson(m_jsonName, m_jsonSetting); } public static void UpdateJson(AnnouncerJsonSetting jsonSetting) { m_jsonSetting = jsonSetting; UpdateAnnouncerJson(); } private static void PluginConfigPanelInitialization(string announcerName, AnnouncerJsonSetting jsonSetting) { PluginDependencies.LoadIfPluginExists("com.eternalUnion.pluginConfigurator", "RegisterRankAnnouncerPage", delegate { ReflectionManager.LoadByReflection("greycsont.GreyAnnouncer.RegisterRankAnnouncerPage", "Build", new object[2] { announcerName, jsonSetting }); }); } private static void UpdateAnnouncerJson() { m_announcer.UpdateJsonSetting(m_jsonSetting); JsonManager.WriteJson(m_jsonName, m_jsonSetting); } } public static class RegisterRankAnnouncerPage { private static PluginConfigurator m_pluginConfigurator; private static string m_title; private static readonly Color HeaderColor = new Color(0.85f, 0.85f, 0.85f, 1f); public static void Build(string title, AnnouncerJsonSetting announcerJsonSetting) { //IL_0032: Unknown result type (might be due to invalid IL or missing references) //IL_0038: Expected O, but got Unknown //IL_003e: Unknown result type (might be due to invalid IL or missing references) //IL_004c: Unknown result type (might be due to invalid IL or missing references) //IL_0052: Expected O, but got Unknown //IL_0053: Unknown result type (might be due to invalid IL or missing references) m_pluginConfigurator = PluginConfiguratorEntry.config; m_title = title; ConfigPanel val = new ConfigPanel(m_pluginConfigurator.rootPanel, m_title, m_title); new ConfigSpace(val, 15f); ConfigHeader val2 = new ConfigHeader(val, m_title, 24); val2.textColor = HeaderColor; Action<BoolValueChangeEvent>[] callbacks = new Action<BoolValueChangeEvent>[1] { delegate { RankAnnouncerV2.UpdateJson(announcerJsonSetting); LogManager.LogInfo("Updated json setting for " + m_title); } }; foreach (KeyValuePair<string, CategoryAudioSetting> item in announcerJsonSetting.CategoryAudioMap) { BoolField val3 = CreateBoolField(val, item.Value.DisplayName, item.Key, announcerJsonSetting, defaultValue: true, callbacks); } } private static BoolField CreateBoolField(ConfigPanel panel, string label, string guid, AnnouncerJsonSetting jsonSetting, bool defaultValue, Action<BoolValueChangeEvent>[] callbacks = null) { //IL_0047: Unknown result type (might be due to invalid IL or missing references) //IL_004d: Expected O, but got Unknown //IL_005d: Unknown result type (might be due to invalid IL or missing references) //IL_0067: Expected O, but got Unknown string text = GuidPrefixAdder.AddPrefixToGUID(guid); BoolField val = new BoolField(panel, label, text, jsonSetting.CategoryAudioMap[guid].Enabled); val.defaultValue = defaultValue; val.onValueChange += (BoolValueChangeEventDelegate)delegate(BoolValueChangeEvent e) { if (jsonSetting.CategoryAudioMap.ContainsKey(guid)) { jsonSetting.CategoryAudioMap[guid].Enabled = e.value; } if (callbacks != null) { Action<BoolValueChangeEvent>[] array = callbacks; for (int i = 0; i < array.Length; i++) { array[i]?.Invoke(e); } } }; return val; } } [HarmonyPatch(typeof(StyleHUD), "AscendRank")] public static class StyleHUDAscendRank_Patch { private static void Postfix(StyleHUD __instance) { int rankIndex = __instance.rankIndex; if (rankIndex >= 0 && rankIndex <= 7) { RankAnnouncerV2.PlayRankSound(rankIndex); } } } [HarmonyPatch(typeof(StyleHUD), "ComboStart")] public class StyleHUDComboStart_Patch { private static void Postfix(StyleHUD __instance) { if (__instance.rankIndex == 0) { RankAnnouncerV2.PlayRankSound(0); } } } public static class InstanceConfig { public static ConfigEntry<float> sharedPlayCooldown; public static ConfigEntry<float> individualPlayCooldown; public static ConfigEntry<float> audioSourceVolume; public static ConfigEntry<bool> isLowPassFilterEnabled; public static ConfigEntry<string> audioFolderPath; public static ConfigEntry<int> audioPlayOptions; public static ConfigEntry<int> audioLoadingOptions; public static ConfigEntry<bool> isAudioRandomizationEnabled; public static readonly Dictionary<string, (string section, string name, object defaultValue, string description)> ConfigEntries = new Dictionary<string, (string, string, object, string)> { { "SharedRankCooldown", ("Cooldown", "Shared_rank_play_cooldown", DEFAULT_SHARED_PLAY_COOLDOWN, "Shared rank play cooldown (in secs)") }, { "IndividualRankCooldown", ("Cooldown", "Individual_rank_play_cooldown", DEFAULT_INDIVIDUAL_PLAY_COOLDOWN, "Individual rank play cooldown (in secs)") }, { "AudioSourceVolume", ("Audio", "Audio_source_volume", DEFAULT_AUDIO_SOURCE_VOLUME, "Volume of the Announcer ( Range : 0f ~ 1f )") }, { "LowPassFilter", ("Audio", "Under_water_low_pass_filter_Enabled", DEFAULT_LOW_PASS_FILTER_ENABLED, "Set to true to enable muffle effect when under water") }, { "AudioFolderPath", ("Audio", "Audio_folder_path", DEFAULT_AUDIO_FOLDER_PATH, "Path to the audio folder") }, { "AudioPlayOptions", ("Audio", "Audio_Play_Option", DEFAULT_AUDIO_PLAY_OPTIONS, "0 : new audio will override the old one, 1 : audio will not effect each other") }, { "AudioLoadingOption", ("Audio", "Audio_Loading_Option", DEFAULT_AUDIO_LOADING_OPTIONS, "0 : load clip from file (less RAM more latency), 1 : preload clip to games (less latency more RAM)") }, { "Randomization", ("Advance", "Audio_Randomization", DEFAULT_AUDIO_RANDOMIZATION_ENABLED, "Set to true to enable audio randomlization of announcer (randomly selected a available audio)") } }; private static float m_defaultSharedPlayCooldown = 0f; private static float m_defaultIndividualPlayCooldown = 3f; private static float m_defaultAudioSourceVolume = 1f; private static bool m_defaultLowPassFilterEnabled = true; private static string m_audioFolderPath; private static int m_defaultAudioPlayOptions = 0; private static int m_defaultAudioLoadingOptions = 0; private static bool m_defaultAudioRandomizationEnabled = false; public static float DEFAULT_SHARED_PLAY_COOLDOWN { get { return m_defaultSharedPlayCooldown; } private set { m_defaultSharedPlayCooldown = value; } } public static float DEFAULT_INDIVIDUAL_PLAY_COOLDOWN { get { return m_defaultIndividualPlayCooldown; } private set { m_defaultIndividualPlayCooldown = value; } } public static float DEFAULT_AUDIO_SOURCE_VOLUME { get { return m_defaultAudioSourceVolume; } private set { m_defaultAudioSourceVolume = value; } } public static bool DEFAULT_LOW_PASS_FILTER_ENABLED { get { return m_defaultLowPassFilterEnabled; } private set { m_defaultLowPassFilterEnabled = value; } } public static string DEFAULT_AUDIO_FOLDER_PATH { get { return m_audioFolderPath ?? PathManager.GetCurrentPluginPath("Audio"); } private set { m_audioFolderPath = value; } } public static int DEFAULT_AUDIO_PLAY_OPTIONS { get { return (m_defaultAudioPlayOptions < 2) ? m_defaultAudioPlayOptions : 0; } private set { m_defaultAudioPlayOptions = value; } } public static int DEFAULT_AUDIO_LOADING_OPTIONS { get { return (m_defaultAudioLoadingOptions < 2) ? m_defaultAudioLoadingOptions : 0; } private set { m_defaultAudioLoadingOptions = value; } } public static bool DEFAULT_AUDIO_RANDOMIZATION_ENABLED { get { return m_defaultAudioRandomizationEnabled; } private set { m_defaultAudioRandomizationEnabled = value; } } public static void Initialize(Plugin plugin) { DEFAULT_AUDIO_FOLDER_PATH = PathManager.GetCurrentPluginPath("Audio"); BindConfigEntryValues(plugin); } private static void BindConfigEntryValues(Plugin plugin) { foreach (KeyValuePair<string, (string, string, object, string)> configEntry in ConfigEntries) { BindConfigEntry(plugin, configEntry.Key, configEntry.Value.Item1, configEntry.Value.Item2, configEntry.Value.Item3, configEntry.Value.Item4); } } private static void BindConfigEntry(Plugin plugin, string key, string section, string name, object defaultValue, string description) { if (defaultValue is bool) { ConfigEntry<bool> val = ((BaseUnityPlugin)plugin).Config.Bind<bool>(section, name, (bool)defaultValue, description); if (name == "Under_water_low_pass_filter_Enabled") { isLowPassFilterEnabled = val; } else if (name == "Audio_Randomization") { isAudioRandomizationEnabled = val; } } else if (defaultValue is float) { ConfigEntry<float> val2 = ((BaseUnityPlugin)plugin).Config.Bind<float>(section, name, (float)defaultValue, description); switch (name) { case "Shared_rank_play_cooldown": sharedPlayCooldown = val2; break; case "Individual_rank_play_cooldown": individualPlayCooldown = val2; break; case "Audio_source_volume": audioSourceVolume = val2; break; } } else if (defaultValue is string) { ConfigEntry<string> val3 = ((BaseUnityPlugin)plugin).Config.Bind<string>(section, name, (string)defaultValue, description); if (name == "Audio_folder_path") { audioFolderPath = val3; } } else if (defaultValue is int) { ConfigEntry<int> val4 = ((BaseUnityPlugin)plugin).Config.Bind<int>(section, name, (int)defaultValue, description); if (name == "Audio_Play_Option") { audioPlayOptions = val4; } else if (name == "Audio_Loading_Option") { audioLoadingOptions = val4; } } else { LogManager.LogError("Unsupported type for config entry: " + key + ", Type: " + (defaultValue?.GetType()?.FullName ?? "null")); } } } }