using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Data;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
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.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
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: 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 3.5")]
[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 = Thread.VolatileRead(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;
Thread.VolatileWrite(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);
}
[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),
_ => 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 ((object)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;
}
}
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;
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 = Convert.ToDouble(value, CultureInfo.InvariantCulture);
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 = Convert.ToBoolean(Value, CultureInfo.InvariantCulture);
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;
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.GetValueOrDefault();
}
set
{
_preserveReferencesHandling = value;
}
}
public TypeNameHandling TypeNameHandling
{
get
{
return _typeNameHandling.GetValueOrDefault();
}
set
{
_typeNameHandling = value;
}
}
public MetadataPropertyHandling MetadataPropertyHandling
{
get
{
return _metadataPropertyHandling.GetValueOrDefault();
}
set
{
_metadataPropertyHandling = value;
}
}
[Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
public FormatterAssemblyStyle TypeNameAssemblyFormat
{
get
{
return (FormatterAssemblyStyle)TypeNameAssemblyFormatHandling;
}
set
{
TypeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
}
}
public TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
{
get
{
return _typeNameAssemblyFormatHandling.GetValueOrDefault();
}
set
{
_typeNameAssemblyFormatHandling = value;
}
}
public ConstructorHandling ConstructorHandling
{
get
{
return _constructorHandling.GetValueOrDefault();
}
set
{
_constructorHandling = value;
}
}
public IContractResolver? ContractResolver { get; set; }
public IEqualityComparer? EqualityComparer { get; set; }
[Obsolete("ReferenceResolver property is obsolete. Use the ReferenceResolverProvider property to set the IReferenceResolver: settings.ReferenceResolverProvider = () => resolver")]
public IReferenceResolver? ReferenceResolver
{
get
{
return ReferenceResolverProvider?.Invoke();
}
set
{
IReferenceResolver value2 = value;
ReferenceResolverProvider = ((value2 != null) ? ((Func<IReferenceResolver>)(() => value2)) : null);
}
}
public Func<IReferenceResolver?>? ReferenceResolverProvider { get; set; }
public ITraceWriter? TraceWriter { get; set; }
[Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
public SerializationBinder? Binder
{
get
{
if (SerializationBinder == null)
{
return null;
}
if (SerializationBinder is SerializationBinderAdapter serializationBinderAdapter)
{
return serializationBinderAdapter.SerializationBinder;
}
throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set.");
}
set
{
SerializationBinder = ((value == null) ? null : new SerializationBinderAdapter(value));
}
}
public ISerializationBinder? SerializationBinder { get; set; }
public EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs>? Error { get; set; }
public StreamingContext Context
{
get
{
return _context ?? DefaultContext;
}
set
{
_context = value;
}
}
public string DateFormatString
{
get
{
return _dateFormatString ?? "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
}
set
{
_dateFormatString = value;
_dateFormatStringSet = true;
}
}
public int? MaxDepth
{
get
{
if (!_maxDepthSet)
{
return 64;
}
return _maxDepth;
}
set
{
if (value <= 0)
{
throw new ArgumentException("Value must be positive.", "value");
}
_maxDepth = value;
_maxDepthSet = true;
}
}
public Formatting Formatting
{
get
{
return _formatting.GetValueOrDefault();
}
set
{
_formatting = value;
}
}
public DateFormatHandling DateFormatHandling
{
get
{
return _dateFormatHandling.GetValueOrDefault();
}
set
{
_dateFormatHandling = value;
}
}
public DateTimeZoneHandling DateTimeZoneHandling
{
get
{
return _dateTimeZoneHandling ?? DateTimeZoneHandling.RoundtripKind;
}
set
{
_dateTimeZoneHandling = value;
}
}
public DateParseHandling DateParseHandling
{
get
{
return _dateParseHandling ?? DateParseHandling.DateTime;
}
set
{
_dateParseHandling = value;
}
}
public FloatFormatHandling FloatFormatHandling
{
get
{
return _floatFormatHandling.GetValueOrDefault();
}
set
{
_floatFormatHandling = value;
}
}
public FloatParseHandling FloatParseHandling
{
get
{
return _floatParseHandling.GetValueOrDefault();
}
set
{
_floatParseHandling = value;
}
}
public StringEscapeHandling StringEscapeHandling
{
get
{
return _stringEscapeHandling.GetValueOrDefault();
}
set
{
_stringEscapeHandling = value;
}
}
public CultureInfo Culture
{
get
{
return _culture ?? DefaultCulture;
}
set
{
_culture = value;
}
}
public bool CheckAdditionalContent
{
get
{
return _checkAdditionalContent.GetValueOrDefault();
}
set
{
_checkAdditionalContent = value;
}
}
static JsonSerializerSettings()
{
DefaultContext = default(StreamingContext);
DefaultCulture = CultureInfo.InvariantCulture;
}
[DebuggerStepThrough]
public JsonSerializerSettings()
{
Converters = new List<JsonConverter>();
}
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Xml;
using System.Xml.Serialization;
using HarmonyLib;
using Localisation;
using Networking;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using RocketLib;
using RocketLib.Loggers;
using RocketLib.Menus.Core;
using RocketLib.Menus.Elements;
using RocketLib.Menus.Layout;
using RocketLib.Menus.Tests;
using RocketLib.Menus.Utilities;
using RocketLib.Menus.Vanilla;
using RocketLib.UMM;
using RocketLib.Utils;
using TFBGames.Management.Asset;
using TFBGames.Systems;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityModManagerNet;
using Utility;
using World.LevelEdit.Triggers;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("RocketLib")]
[assembly: AssemblyCompany("Gorzontrok")]
[assembly: AssemblyProduct("RocketLib")]
[assembly: AssemblyCopyright("Copyright © Gorzontrok 2025")]
[assembly: ComVisible(false)]
[assembly: Guid("a6375eb5-1a4c-48e5-b2bf-2ced7175edf4")]
[assembly: AssemblyFileVersion("2.4.0")]
[assembly: AssemblyVersion("2.4.0.0")]
public static class DictionarySerializationExtensions
{
public static SerializableKeyValuePair<TKey, TValue>[] ToSerializableArray<TKey, TValue>(this Dictionary<TKey, TValue> dictionary)
{
if (dictionary == null)
{
return new SerializableKeyValuePair<TKey, TValue>[0];
}
return dictionary.Select((KeyValuePair<TKey, TValue> kvp) => new SerializableKeyValuePair<TKey, TValue>(kvp.Key, kvp.Value)).ToArray();
}
public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue>(this SerializableKeyValuePair<TKey, TValue>[] array)
{
if (array == null)
{
return new Dictionary<TKey, TValue>();
}
return Enumerable.ToDictionary(array, (SerializableKeyValuePair<TKey, TValue> kvp) => kvp.Key, (SerializableKeyValuePair<TKey, TValue> kvp) => kvp.Value);
}
public static TWrapper[] ToSerializableArray<TKey, TValue, TWrapper>(this Dictionary<TKey, TValue> dictionary, Func<KeyValuePair<TKey, TValue>, TWrapper> converter)
{
if (dictionary == null)
{
return new TWrapper[0];
}
return dictionary.Select(converter).ToArray();
}
public static Dictionary<TKey, TValue> ToDictionary<TKey, TValue, TWrapper>(this TWrapper[] array, Func<TWrapper, TKey> keySelector, Func<TWrapper, TValue> valueSelector)
{
if (array == null)
{
return new Dictionary<TKey, TValue>();
}
return Enumerable.ToDictionary(array, keySelector, valueSelector);
}
}
public static class EnumeratorExtensions
{
public static T[] GetValues<T>(this T enumerator) where T : Enum
{
if (!typeof(T).IsEnum)
{
throw new ArgumentException("T must be an enum type");
}
return (T[])Enum.GetValues(typeof(T));
}
public static string[] GetValuesAsStrings<T>(this T enumerator) where T : Enum
{
T[] values = enumerator.GetValues();
string[] array = new string[values.Length];
for (int i = 0; i < values.Length; i++)
{
array[i] = values[i].ToString();
}
return array;
}
public static string[] AsStrings<T>(this T[] enumerators) where T : Enum
{
string[] array = new string[enumerators.Length];
for (int i = 0; i < enumerators.Length; i++)
{
array[i] = enumerators[i].ToString();
}
return array;
}
}
public static class IEnumerableExtensions
{
public static T RandomElement<T>(this IEnumerable<T> self)
{
return self.ElementAt(Random.Range(0, self.Count()));
}
public static int RandomIndex<T>(this IEnumerable<T> self)
{
return Random.Range(0, self.Count());
}
public static bool IsNullOrEmpty<T>(this IEnumerable<T> self)
{
if (self != null)
{
return self.Count() == 0;
}
return true;
}
public static bool IsNotNullOrEmpty<T>(this IEnumerable<T> self)
{
return !self.IsNullOrEmpty();
}
public static T[] Append<T>(this T[] array, T obj)
{
List<T> list = array.ToList();
list.Add(obj);
array = list.ToArray();
return array;
}
}
public static class ObjectExtensions
{
public static void DestroyMe(this Object target)
{
Object.Destroy(target);
}
public static bool Is<T>(this object source)
{
return source is T;
}
public static T As<T>(this object source) where T : class
{
return source as T;
}
public static bool NotAs<T>(this object source) where T : class
{
return source as T == null;
}
public static bool IsTypeOf(this object obj, Type type)
{
return (object)obj.GetType() == type;
}
public static void InvokeBaseMethod(this object obj, Type baseType, string methodName)
{
obj.InvokeBaseMethod<object>(baseType, methodName);
}
public static T InvokeBaseMethod<T>(this object obj, Type baseType, string methodName) where T : class
{
Type type = obj.GetType();
MethodInfo method = baseType.GetMethod(methodName);
if ((object)method == null)
{
throw new MissingMethodException(methodName);
}
if ((object)type == baseType)
{
return method.Invoke(obj, null) as T;
}
if (!type.IsSubclassOf(baseType))
{
throw new Exception($"{type} is not a subclass of {baseType}");
}
IntPtr functionPointer = method.MethodHandle.GetFunctionPointer();
Func<T> func = (Func<T>)Activator.CreateInstance(typeof(Func<T>), obj, functionPointer);
return func();
}
public static void PrintDifferences<T>(this T obj1, T obj2)
{
try
{
RocketMain.Logger.Log("Starting comparison of type " + typeof(T).Name);
List<Difference> list = ObjectComparer.Compare(obj1, obj2);
if (!list.Any())
{
RocketMain.Logger.Log("Objects are identical");
return;
}
RocketMain.Logger.Log($"Found {list.Count} differences:");
int totalWidth = list.Max((Difference d) => d.PropertyPath.Length);
foreach (Difference item in list)
{
string text = item.PropertyPath.PadRight(totalWidth);
RocketMain.Logger.Log(" " + text + " : '" + item.Value1 + "' → '" + item.Value2 + "'");
}
}
catch (Exception ex)
{
RocketMain.Logger.Log("Error during comparison: " + ex.Message);
}
}
public static void GenerateMatchingCode<T>(this T obj1, T obj2)
{
try
{
RocketMain.Logger.Log("Generating matching code for type " + typeof(T).Name);
List<Difference> list = ObjectComparer.Compare(obj2, obj1);
if (!list.Any())
{
RocketMain.Logger.Log("Objects are identical - no matching needed");
return;
}
RocketMain.Logger.Log($"// Code to match {list.Count} differences:");
RocketMain.Logger.Log("// Copy and paste the following code inside the target class:");
RocketMain.Logger.Log("");
List<string> list2 = new List<string>();
foreach (Difference item in list)
{
string text = ObjectComparer.GenerateMatchingStatement(item.PropertyPath, item.Value1);
if (!string.IsNullOrEmpty(text))
{
list2.Add(text);
}
}
if (list2.Any())
{
foreach (string item2 in list2)
{
RocketMain.Logger.Log(item2);
}
return;
}
RocketMain.Logger.Log("// Unable to generate matching code for complex types");
}
catch (Exception ex)
{
RocketMain.Logger.Log("Error generating matching code: " + ex.Message);
}
}
}
public static class SpriteSMExtensions
{
public static void SetTexture(this SpriteSM self, Texture2D texture)
{
if ((Object)(object)texture == (Object)null)
{
throw new ArgumentNullException("texture");
}
self.meshRender.sharedMaterial.mainTexture = (Texture)(object)texture;
}
public static void SetTexture(this SpriteSM self, Texture texture)
{
if ((Object)(object)texture == (Object)null)
{
throw new ArgumentNullException("texture");
}
self.meshRender.sharedMaterial.mainTexture = texture;
}
public static Texture GetTexture(this SpriteSM self)
{
return self.meshRender.sharedMaterial.mainTexture;
}
}
public static class TestVanDammeAnimExtensions
{
public static BroBase AsBroBase(this TestVanDammeAnim self)
{
return (BroBase)(object)((self is BroBase) ? self : null);
}
public static SpriteSM Sprite(this TestVanDammeAnim self)
{
return self.GetFieldValue<SpriteSM>("sprite");
}
public static Sound Sound(this TestVanDammeAnim self)
{
return self.GetFieldValue<Sound>("sound");
}
public static Vector2 GetSpriteSize(this TestVanDammeAnim self)
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
return new Vector2((float)self.GetFieldValue<int>("spritePixelWidth"), (float)self.GetFieldValue<int>("spritePixelHeight"));
}
public static void SetSpriteLowerLeftPixel(this TestVanDammeAnim self, int x, int y)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
Vector2 spriteSize = self.GetSpriteSize();
self.Sprite().SetLowerLeftPixel((float)x * spriteSize.x, (float)y * spriteSize.y);
}
public static void SetRendererTexture<T>(this T anim, Texture texture) where T : TestVanDammeAnim
{
((Component)(object)anim).GetComponent<Renderer>().sharedMaterial.SetTexture("_MainTex", texture);
}
public static void SetRendererMaterial<T>(this T anim, Material mat) where T : TestVanDammeAnim
{
((Component)(object)anim).GetComponent<Renderer>().sharedMaterial = mat;
}
public static bool IsOnAnimal<T>(this T anim) where T : TestVanDammeAnim
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_0037: Unknown result type (might be due to invalid IL or missing references)
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Unknown result type (might be due to invalid IL or missing references)
//IL_007f: Unknown result type (might be due to invalid IL or missing references)
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
LayerMask fieldValue = anim.GetFieldValue<LayerMask>("platformLayer");
RaycastHit val = default(RaycastHit);
if (Physics.Raycast(new Vector3(((BroforceObject)(object)anim).X, ((BroforceObject)(object)anim).Y + 5f, 0f), Vector3.down, ref val, 16f, LayerMask.op_Implicit(fieldValue)) || Physics.Raycast(new Vector3(((BroforceObject)(object)anim).X + 4f, ((BroforceObject)(object)anim).Y + 5f, 0f), Vector3.down, ref val, 16f, LayerMask.op_Implicit(fieldValue)) || Physics.Raycast(new Vector3(((BroforceObject)(object)anim).X - 4f, ((BroforceObject)(object)anim).Y + 5f, 0f), Vector3.down, ref val, 16f, LayerMask.op_Implicit(fieldValue)))
{
return (Object)(object)((Component)((RaycastHit)(ref val)).collider).GetComponentInParent<Animal>() != (Object)null;
}
return false;
}
public static void SetReviveSource(this TestVanDammeAnim testVanDammeAnim, TestVanDammeAnim reviveSource)
{
testVanDammeAnim.SetFieldValue<TestVanDammeAnim>("reviveSource", reviveSource);
}
}
public static class HarmonyExtensions
{
public const char PATH_SEPARATOR = '.';
public static Traverse GetTraverse(this object obj)
{
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Expected O, but got Unknown
if (obj is Traverse)
{
return (Traverse)obj;
}
return Traverse.Create(obj);
}
public static T GetFieldValue<T>(this object obj, string fieldName)
{
return obj.GetTraverse().Field(fieldName).GetValue<T>();
}
public static object GetFieldValue(this object obj, string fieldName)
{
return obj.GetTraverse().Field(fieldName).GetValue();
}
public static Traverse SetFieldValue(this object obj, string fieldName, object value)
{
return obj.GetTraverse().Field(fieldName).SetValue(value);
}
public static Traverse SetFieldValue<T>(this object obj, string fieldName, T value)
{
return obj.GetTraverse().Field(fieldName).SetValue((object)value);
}
public static T CallMethod<T>(this object obj, string methodName, params object[] arguments)
{
return obj.GetTraverse().Method(methodName, arguments).GetValue<T>();
}
public static object CallMethod(this object obj, string methodName, params object[] arguments)
{
return obj.GetTraverse().Method(methodName, arguments).GetValue();
}
public static bool GetBool(this object obj, string fieldName)
{
return obj.GetFieldValue<bool>(fieldName);
}
public static float GetFloat(this object obj, string fieldName)
{
return obj.GetFieldValue<float>(fieldName);
}
public static int GetInt(this object obj, string fieldName)
{
return obj.GetFieldValue<int>(fieldName);
}
public static void DynamicFieldsValueSetter(this object obj, Dictionary<string, object> map, string[] skipTheseFields = null, Action<Traverse, string, object> setter = null)
{
if (setter == null)
{
setter = delegate(Traverse t, string s, object o)
{
t.SetValue(o);
};
}
if (skipTheseFields == null)
{
skipTheseFields = new string[0];
}
Traverse traverse = obj.GetTraverse();
Traverse val = traverse;
foreach (KeyValuePair<string, object> item in map)
{
try
{
if (!Extensions.Contains<string>((Array)skipTheseFields, item.Key))
{
val = traverse.FindFieldWithPath(item.Key);
setter(val, item.Key, item.Value);
}
}
catch (NullReferenceException)
{
}
catch (Exception exception)
{
RocketMain.Logger.Exception($"Key: {item.Key} ; Value: {item.Value}\nAt type field {val.GetValueType()}", exception);
}
}
}
public static Traverse FindFieldWithPath(this object obj, string fieldPath)
{
return obj.GetTraverse().FindFieldWithPath(fieldPath);
}
public static Traverse FindFieldWithPath(this Traverse traverse, string fieldPath)
{
Traverse val = traverse;
string[] array = fieldPath.Split(new char[1] { '.' });
string[] array2 = array;
foreach (string text in array2)
{
val = val.Field(text);
}
return val;
}
}
public enum RLogType
{
Log,
Warning,
Error,
Exception,
Information
}
namespace RocketLib
{
public static class UnitExtensions
{
public static void SetIsZombie(this Unit unit, bool isZombie)
{
unit.SetFieldValue("isZombie", isZombie);
}
}
public static class RocketMain
{
public const string NEWTONSOFT_ASSEMBLY_NAME = "Newtonsoft.Json.dll";
internal static ILogger Logger;
public static bool Loaded { get; private set; }
public static Settings settings => Main.settings;
public static void Load(ModEntry _mod)
{
if (Loaded)
{
Logger.Log("Cancel Load, already Started.");
return;
}
Logger = new Logger();
try
{
Assembly.LoadFile(Path.Combine(Main.Mod.Path, "Newtonsoft.Json.dll"));
}
catch (Exception exception)
{
Logger.Exception("Error while loading Newtonsoft.Json", exception);
}
Loaded = true;
}
private static void RegisterTestMenus()
{
MenuRegistry.RegisterMenu<BasicFlexMenuExample>("Basic Flex Menu Test", TargetMenu.MainMenu, PositionMode.Auto, "OPTIONS");
MenuRegistry.RegisterMenu<VanillaSubmenuExample>("Vanilla Submenu Test", TargetMenu.MainMenu, PositionMode.Auto, "OPTIONS");
MenuRegistry.RegisterMenu<ModOptionsExample>("Test Mod Options", TargetMenu.ModOptions);
MenuRegistry.RegisterMenu<GridLayoutExample>("Grid Layout Test", TargetMenu.MainMenu, PositionMode.Auto, "OPTIONS");
MenuRegistry.RegisterMenu<PaginatedGridExample>("Paginated Grid Test", TargetMenu.MainMenu, PositionMode.Auto, "OPTIONS");
MenuRegistry.RegisterMenu<TransitionTestMenu>("Transition Test", TargetMenu.MainMenu, PositionMode.Auto, "OPTIONS");
Logger.Log("Test menus registered successfully");
}
}
internal static class Constants
{
public const string NAME = "RocketLib";
public const string VERSION = "2.4.0";
public const string AUTHOR = "Gorzontrok";
}
public static class BroforceObjectExtensions
{
public static void SetRendererTexture<T>(this T anim, Texture texture) where T : BroforceObject
{
((Component)(object)anim).GetComponent<Renderer>().sharedMaterial.SetTexture("_MainTex", texture);
}
public static void SetRendererMaterial<T>(this T anim, Material mat) where T : BroforceObject
{
((Component)(object)anim).GetComponent<Renderer>().sharedMaterial = mat;
}
public static void HurtWildLife<T>(this T unit, float range) where T : BroforceObject
{
Map.HurtWildLife(((BroforceObject)unit).X, ((BroforceObject)unit).Y, range);
}
public static void AttractAliens<T>(this T unit, Vector2 range) where T : NetworkedUnit
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
unit.AttractAliens(range.x, range.y);
}
public static void AttractAliens<T>(this T unit, float xRange, float yRange) where T : NetworkedUnit
{
Map.AttractAliens(((BroforceObject)(object)unit).X, ((BroforceObject)(object)unit).Y, xRange, yRange);
}
public static void AttractMooks<T>(this T unit, Vector2 range) where T : NetworkedUnit
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
unit.AttractMooks(range.x, range.y);
}
public static void AttractMooks<T>(this T unit, float xRange, float yRange) where T : NetworkedUnit
{
Map.AttractMooks(((BroforceObject)(object)unit).X, ((BroforceObject)(object)unit).Y, xRange, yRange);
}
}
public static class ComponentExtensions
{
public static void RemoveComponent<T>(this Component self) where T : Component
{
self.gameObject.RemoveComponent<T>();
}
public static bool HasComponent<T>(this Component self) where T : Component
{
return self.gameObject.HasComponent<T>();
}
public static T GetOrAddComponent<T>(this Component self) where T : Component
{
return self.gameObject.GetOrAddComponent<T>();
}
public static T GetComponent<T>(this Component self, Action<T> action) where T : Component
{
return self.gameObject.GetComponent(action);
}
public static GameObject FindChildOfName(this Component component, string name)
{
Transform transform = component.transform;
int childCount = transform.childCount;
for (int i = 0; i < childCount; i++)
{
Transform child = transform.GetChild(i);
if (((Object)((Component)child).gameObject).name == name)
{
return ((Component)child).gameObject;
}
}
return null;
}
public static GameObject[] ToGameObjects<T>(this T[] components) where T : Component
{
List<GameObject> list = new List<GameObject>();
foreach (T val in components)
{
list.Add(((Component)val).gameObject);
}
return list.ToArray();
}
}
[Serializable]
public class SerializableKeyValuePair<TKey, TValue>
{
[XmlElement("Key")]
public TKey Key { get; set; }
[XmlElement("Value")]
public TValue Value { get; set; }
public SerializableKeyValuePair()
{
}
public SerializableKeyValuePair(TKey key, TValue value)
{
Key = key;
Value = value;
}
}
public static class GameObjectExtensions
{
public static void RemoveComponent<T>(this GameObject self) where T : Component
{
Object.Destroy((Object)(object)self.GetComponent<T>());
}
public static bool HasComponent<T>(this GameObject self) where T : Component
{
return (Object)(object)self.GetComponent<T>() != (Object)null;
}
public static T GetOrAddComponent<T>(this GameObject self) where T : Component
{
T val = self.GetComponent<T>();
if ((Object)(object)val == (Object)null)
{
val = self.AddComponent<T>();
}
return val;
}
public static T GetComponent<T>(this GameObject self, Action<T> action) where T : Component
{
T component = self.GetComponent<T>();
if ((Object)(object)component != (Object)null)
{
action(component);
}
return component;
}
public static GameObject FindChildOfName(this GameObject gameObject, string name)
{
Transform transform = gameObject.transform;
int childCount = transform.childCount;
for (int i = 0; i < childCount; i++)
{
Transform child = transform.GetChild(i);
if (((Object)((Component)child).gameObject).name == name)
{
return ((Component)child).gameObject;
}
}
return null;
}
public static string GetPath(this GameObject self)
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)self == (Object)null)
{
return "NULL";
}
Transform val = self.transform;
StringBuilder stringBuilder = new StringBuilder(((Object)self).name);
while ((Object)(object)val.parent != (Object)null)
{
val = val.parent;
stringBuilder.Insert(0, new StringBuilder(((Object)val).name).Append('/'));
}
Scene scene = self.scene;
stringBuilder.Insert(0, new StringBuilder(((Scene)(ref scene)).name).Append('/'));
return stringBuilder.ToString();
}
public static void SetParentAndResetScale(this Transform transform, Transform parent, Vector3? localPosition = null)
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
transform.SetParent(parent);
transform.localScale = Vector3.one;
if (localPosition.HasValue)
{
transform.localPosition = localPosition.Value;
}
}
}
public static class NetworkedUnitExtensions
{
public static bool IsPlayer(this NetworkedUnit self)
{
if ((Object)(object)((self is TestVanDammeAnim) ? self : null) != (Object)null && (Object)(object)self.As<TestVanDammeAnim>().player != (Object)null && self.playerNum >= 0)
{
return self.playerNum < 4;
}
return false;
}
public static bool IsPlayerSide(this NetworkedUnit self)
{
return self.playerNum >= 0;
}
public static bool IsPlayerSideAndNotPlayer(this NetworkedUnit self)
{
return self.playerNum >= 4;
}
public static bool IsTerrorist(this NetworkedUnit self)
{
if (self.playerNum == -1)
{
return Object.op_Implicit((Object)(object)((self is TestVanDammeAnim) ? self : null));
}
return false;
}
public static bool IsAlien(this NetworkedUnit self)
{
if (self.playerNum == -2)
{
return Object.op_Implicit((Object)(object)((self is Alien) ? self : null));
}
return false;
}
public static bool IsEnemy(this NetworkedUnit self)
{
if (self.IsEnemy)
{
if (!self.IsTerrorist())
{
return self.IsAlien();
}
return true;
}
return false;
}
public static void DisturbWildLife<T>(this T unit, float range) where T : NetworkedUnit
{
Map.DisturbWildLife(((BroforceObject)(object)unit).X, ((BroforceObject)(object)unit).Y, range, ((NetworkedUnit)unit).playerNum);
}
public static bool DamageDoodads<T>(this T unit, int damage, DamageType damageType, float range, Vector2 force, out bool hitImpenetrableDoodad) where T : NetworkedUnit
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
return Map.DamageDoodads(damage, damageType, ((BroforceObject)(object)unit).X, ((BroforceObject)(object)unit).Y, force.x, force.y, range, ((NetworkedUnit)unit).playerNum, ref hitImpenetrableDoodad, (MonoBehaviour)(object)unit);
}
public static void AlertNearbyMooks<T>(this T unit, Vector2 range) where T : NetworkedUnit
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
unit.AlertNearbyMooks(range.x, range.y);
}
public static void AlertNearbyMooks<T>(this T unit, float xRange, float yRange) where T : NetworkedUnit
{
Map.AlertNearbyMooks(((BroforceObject)(object)unit).X, ((BroforceObject)(object)unit).Y, xRange, yRange, ((NetworkedUnit)unit).playerNum);
}
public static void AlertNearbyMooks<T>(this T unit, Vector2 range, GridPoint startPoint) where T : NetworkedUnit
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
unit.AlertNearbyMooks(range.x, range.y, startPoint);
}
public static void AlertNearbyMooks<T>(this T unit, float xRange, float yRange, GridPoint startPoint) where T : NetworkedUnit
{
Map.AlertNearbyMooks(((BroforceObject)(object)unit).X, ((BroforceObject)(object)unit).Y, xRange, yRange, ((NetworkedUnit)unit).playerNum, startPoint);
}
public static void BlindUnits<T>(this T unit, float range, float blindTime = 9f) where T : NetworkedUnit
{
Map.BlindUnits(((NetworkedUnit)unit).playerNum, ((BroforceObject)(object)unit).X, ((BroforceObject)(object)unit).Y, range, blindTime);
}
public static void BotherNearbyMooks<T>(this T unit, Vector2 range) where T : NetworkedUnit
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
unit.BotherNearbyMooks(range.x, range.y);
}
public static void BotherNearbyMooks<T>(this T unit, float xRange, float yRange) where T : NetworkedUnit
{
Map.BotherNearbyMooks(((BroforceObject)(object)unit).X, ((BroforceObject)(object)unit).Y, xRange, yRange, ((NetworkedUnit)unit).playerNum);
}
public static void BurnUnitsAround_Local<T>(this T unit, int damage, float range, bool penetrates = false, bool setGroundAlight = false) where T : NetworkedUnit
{
Map.BurnUnitsAround_Local((MonoBehaviour)(object)unit, ((NetworkedUnit)unit).playerNum, damage, range, ((BroforceObject)(object)unit).X, ((BroforceObject)(object)unit).Y, penetrates, setGroundAlight);
}
}
public static class PlayerHUDExtensions
{
public static void SetGrenadesMaterials(this PlayerHUD playerHUD, Material[] materials)
{
Material val = null;
for (int i = 0; i < playerHUD.grenadeIcons.Length; i++)
{
if (i >= materials.Length)
{
if ((Object)(object)val == (Object)null)
{
val = GameSystems.ResourceManager.LoadAssetSync<Material>("sharedtextures:GrenadeIcon");
}
((Component)playerHUD.grenadeIcons[i]).GetComponent<Renderer>().material = val;
}
else
{
((Component)playerHUD.grenadeIcons[i]).GetComponent<Renderer>().material = materials[i];
}
}
}
public static Material GetPockettedMaterial(this PlayerHUD hud, PockettedSpecialAmmoType type)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected I4, but got Unknown
return (Material)((type - 2) switch
{
0 => hud.brodellWalkerIcon,
1 => hud.timebroIcon,
2 => hud.bronnarIcon,
3 => hud.mechDropIcon,
4 => hud.alienPheromones,
5 => hud.steroids,
_ => null,
});
}
}
public static class StringExtensions
{
public const string COLOR_START = "<color=";
public const string COLOR_END = "</color>";
public static string Dye(this string self, Color color)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return self.Dye(Extensions.ToHex(color));
}
public static string Dye(this string self, string hex)
{
StringBuilder stringBuilder = new StringBuilder("<color=").Append(hex).Append(self).Append('>')
.Append("</color>");
self = stringBuilder.ToString();
return self;
}
}
public static class TypeExtensions
{
public static bool CanBeNull(this Type type)
{
if (type.IsValueType)
{
return (object)Nullable.GetUnderlyingType(type) != null;
}
return true;
}
}
public class GamePassword
{
public const string THE_LONG_ONE = "IThinkPuttingMyTesticalsInSomeoneElseFaceWithoutTheirConsentIsOkay";
public const string ALASKAN_PIPELINE = "alaskanpipeline";
public const string SEAGULL = "seagull";
public const string MR_ANDERBRO = "mranderbro";
public const string ABRAHAM_LINCOLN = "abrahamlincoln";
public const string SMOKING_GUN = "smokinggun";
public const string I_LOVE_AMERICA = "iloveamerica";
private static List<GamePassword> _passwords = new List<GamePassword>();
public readonly string password = string.Empty;
public readonly Action action;
public static GamePassword[] Passwords => _passwords.ToArray();
public GamePassword(string _password, Action _action)
{
password = _password.ToLower();
action = _action;
AddPassword(this);
}
public override string ToString()
{
return password;
}
private static void AddPassword(GamePassword password)
{
_passwords.Add(password);
RocketMain.Logger.Debug("added password");
}
}
[HarmonyPatch(typeof(MainMenu))]
public class MainMenuPatch
{
[HarmonyPatch("ProcessCharacter")]
[HarmonyPostfix]
private static void CheckCustomPassword(MainMenu __instance)
{
GamePassword[] passwords = GamePassword.Passwords;
foreach (GamePassword gamePassword in passwords)
{
try
{
if (__instance.CallMethod<bool>("CheckCheatString", new object[1] { gamePassword.password }))
{
Sound instance = Sound.GetInstance();
instance.PlaySoundEffect(((Menu)__instance).drumSounds.specialSounds[0], 0.75f);
gamePassword.action?.Invoke();
}
}
catch (Exception exception)
{
RocketMain.Logger.Exception("Failed to check the password: " + gamePassword.password, exception);
}
}
}
}
[Flags]
public enum ModifierKeys
{
None = 0,
Ctrl = 1,
Shift = 2,
Alt = 4
}
[Serializable]
public class KeyBinding : IEquatable<KeyBinding>
{
[CompilerGenerated]
private sealed class <BindKey>d__30 : IEnumerator<object>, IDisposable, IEnumerator
{
private int <>1__state;
private object <>2__current;
public KeyBinding keyBinding;
private KeyCode[] <keyCodes>5__2;
private bool <exit>5__3;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <BindKey>d__30(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<keyCodes>5__2 = null;
<>1__state = -2;
}
private bool MoveNext()
{
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Expected O, but got Unknown
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Invalid comparison between Unknown and I4
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Invalid comparison between Unknown and I4
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b7: Invalid comparison between Unknown and I4
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: Invalid comparison between Unknown and I4
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Invalid comparison between Unknown and I4
//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d8: Invalid comparison between Unknown and I4
//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
InputReader.IsBlocked = true;
<>2__current = (object)new WaitForSeconds(0.1f);
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
<keyCodes>5__2 = Enum.GetValues(typeof(KeyCode)).Cast<KeyCode>().ToArray();
<exit>5__3 = false;
playstationControllers = new bool[4];
break;
case 2:
<>1__state = -1;
break;
}
if (!<exit>5__3)
{
KeyCode[] array = <keyCodes>5__2;
foreach (KeyCode val in array)
{
if (Input.GetKeyUp(val) && (int)val != 306 && (int)val != 305 && (int)val != 304 && (int)val != 303 && (int)val != 308 && (int)val != 307)
{
keyBinding.AssignKey(val);
keyBinding.modifiers = ModifierKeys.None;
if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305))
{
keyBinding.modifiers |= ModifierKeys.Ctrl;
}
if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
{
keyBinding.modifiers |= ModifierKeys.Shift;
}
if (Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307))
{
keyBinding.modifiers |= ModifierKeys.Alt;
}
<exit>5__3 = true;
break;
}
}
for (int j = 1; j < 5; j++)
{
if (playstationControllers[j - 1])
{
for (int k = 1; k < 9; k++)
{
string text = "Joy" + j + " Axis " + k;
if (k == 4 || k == 5)
{
if ((Input.GetAxis(text) + 1f) / 2f >= keyBinding.axisThreshold)
{
keyBinding.playStation = true;
keyBinding.AssignKey(text, (int)Mathf.Sign(Input.GetAxis(text)));
<exit>5__3 = true;
break;
}
}
else if (Mathf.Abs(Input.GetAxis(text)) >= keyBinding.axisThreshold)
{
keyBinding.playStation = true;
keyBinding.AssignKey(text, (int)Mathf.Sign(Input.GetAxis(text)));
<exit>5__3 = true;
break;
}
}
continue;
}
for (int l = 1; l < 9; l++)
{
string text2 = "Joy" + j + " Axis " + l;
if (Mathf.Abs(Input.GetAxis(text2)) >= keyBinding.axisThreshold)
{
string[] joystickNames = Input.GetJoystickNames();
if (joystickNames.Length <= j - 1 || !joystickNames[j - 1].ToLower().Contains("wireless controller"))
{
keyBinding.playStation = false;
keyBinding.AssignKey(text2, (int)Mathf.Sign(Input.GetAxis(text2)));
<exit>5__3 = true;
break;
}
playstationControllers[j - 1] = true;
j--;
}
}
}
<>2__current = null;
<>1__state = 2;
return true;
}
InputReader.IsBlocked = false;
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public string name;
public KeyCode key;
public bool axis;
public string joystickAxis;
public int joystickDirection = 1;
public float axisThreshold = 0.8f;
public string joystickDisplayName;
public bool playStation;
public int axisNum = -1;
public ModifierKeys modifiers;
[JsonIgnore]
[XmlIgnore]
public bool isSettingKey;
[JsonIgnore]
[XmlIgnore]
public static Rect toolTipRect;
[JsonIgnore]
[XmlIgnore]
public bool wasDown;
[JsonIgnore]
[XmlIgnore]
public static bool[] playstationControllers = new bool[4];
public KeyBinding()
{
name = string.Empty;
AssignKey((KeyCode)0);
}
public KeyBinding(string name)
{
this.name = name;
AssignKey((KeyCode)0);
}
public virtual bool Equals(KeyBinding other)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
if (other == null)
{
return false;
}
if (axis || axis != other.axis || key != other.key || modifiers != other.modifiers)
{
if (axis && axis == other.axis)
{
return joystickAxis == other.joystickAxis;
}
return false;
}
return true;
}
public override bool Equals(object obj)
{
if (obj == null)
{
return false;
}
KeyBinding keyBinding = obj as KeyBinding;
if (keyBinding == null)
{
return false;
}
return Equals(keyBinding);
}
public static bool operator ==(KeyBinding keyBinding1, KeyBinding keyBinding2)
{
if ((object)keyBinding1 == null || (object)keyBinding2 == null)
{
return object.Equals(keyBinding1, keyBinding2);
}
return keyBinding1.Equals(keyBinding2);
}
public static bool operator !=(KeyBinding keyBinding1, KeyBinding keyBinding2)
{
if ((object)keyBinding1 == null || (object)keyBinding2 == null)
{
return !object.Equals(keyBinding1, keyBinding2);
}
return !keyBinding1.Equals(keyBinding2);
}
public override int GetHashCode()
{
return ((object)(KeyCode)(ref key)).GetHashCode() ^ modifiers.GetHashCode();
}
public bool HasKeyAssigned()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
if ((int)key == 0)
{
return axis;
}
return true;
}
public virtual bool IsDown()
{
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
if (modifiers != 0)
{
ModifierKeys modifierKeys = ModifierKeys.None;
if (Input.GetKey((KeyCode)306) || Input.GetKey((KeyCode)305))
{
modifierKeys |= ModifierKeys.Ctrl;
}
if (Input.GetKey((KeyCode)304) || Input.GetKey((KeyCode)303))
{
modifierKeys |= ModifierKeys.Shift;
}
if (Input.GetKey((KeyCode)308) || Input.GetKey((KeyCode)307))
{
modifierKeys |= ModifierKeys.Alt;
}
if ((modifierKeys & modifiers) != modifiers)
{
return false;
}
}
if (axis)
{
if ((playStation && axisNum == 4) || axisNum == 5)
{
return (Input.GetAxis(joystickAxis) + 1f) / 2f >= axisThreshold;
}
if (Mathf.Abs(Input.GetAxis(joystickAxis)) >= axisThreshold)
{
return Mathf.Sign(Input.GetAxis(joystickAxis)) == (float)joystickDirection;
}
return false;
}
return Input.GetKey(key);
}
public virtual bool PressedDown()
{
bool flag = IsDown();
if (!wasDown && flag)
{
wasDown = flag;
return true;
}
wasDown = flag;
return false;
}
public virtual bool Released()
{
bool flag = IsDown();
if (wasDown && !flag)
{
wasDown = flag;
return false;
}
wasDown = flag;
return true;
}
public virtual float GetAxis()
{
if (axis)
{
return Input.GetAxis(joystickAxis);
}
return -2f;
}
public virtual void AssignKey(KeyCode key)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0003: Invalid comparison between Unknown and I4
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
if ((int)key == 127)
{
key = (KeyCode)0;
}
this.key = key;
axis = false;
joystickAxis = string.Empty;
isSettingKey = false;
playStation = false;
modifiers = ModifierKeys.None;
}
public virtual void AssignKey(string joystick, int joystickDirection)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
key = (KeyCode)0;
axis = true;
joystickAxis = joystick;
axisNum = joystickAxis[joystickAxis.Length - 1] - 48;
float num = Input.GetAxis(joystick);
this.joystickDirection = joystickDirection;
bool flag = this.joystickDirection == 1;
if (!playStation)
{
switch (axisNum)
{
case 1:
joystickDisplayName = "Left Stick " + (flag ? "Right" : "Left");
break;
case 2:
joystickDisplayName = "Left Stick " + (flag ? "Down" : "Up");
break;
case 3:
joystickDisplayName = (flag ? "Left" : "Right") + " Trigger";
break;
case 4:
joystickDisplayName = "Right Stick " + (flag ? "Right" : "Left");
break;
case 5:
joystickDisplayName = "Right Stick " + (flag ? "Down" : "Up");
break;
case 6:
joystickDisplayName = "D-Pad " + (flag ? "Right" : "Left");
break;
case 7:
joystickDisplayName = "D-Pad " + (flag ? "Up" : "Down");
break;
default:
joystickDisplayName = joystickAxis;
break;
}
}
else
{
switch (axisNum)
{
case 1:
joystickDisplayName = "Left Stick " + (flag ? "Right" : "Left");
break;
case 2:
joystickDisplayName = "Left Stick " + (flag ? "Down" : "Up");
break;
case 3:
joystickDisplayName = "Right Stick " + (flag ? "Right" : "Left");
break;
case 4:
joystickDisplayName = "Left Trigger";
break;
case 5:
joystickDisplayName = "Right Trigger";
break;
case 6:
joystickDisplayName = "Right Stick " + (flag ? "Down" : "Up");
break;
case 7:
joystickDisplayName = "D-Pad " + (flag ? "Right" : "Left");
break;
case 8:
joystickDisplayName = "D-Pad " + (flag ? "Up" : "Down");
break;
default:
joystickDisplayName = joystickAxis;
break;
}
}
isSettingKey = false;
}
public virtual void ClearKey()
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
key = (KeyCode)0;
axis = false;
joystickAxis = string.Empty;
isSettingKey = false;
modifiers = ModifierKeys.None;
}
private string GetKeyDisplayString()
{
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
if (axis)
{
return joystickDisplayName;
}
if ((int)key == 0)
{
return "None";
}
string text = "";
if ((modifiers & ModifierKeys.Ctrl) != 0)
{
text += "Ctrl+";
}
if ((modifiers & ModifierKeys.Shift) != 0)
{
text += "Shift+";
}
if ((modifiers & ModifierKeys.Alt) != 0)
{
text += "Alt+";
}
return text + ((object)(KeyCode)(ref key)).ToString();
}
public static IEnumerator BindKey(KeyBinding keyBinding)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <BindKey>d__30(0)
{
keyBinding = keyBinding
};
}
public virtual bool OnGUI(bool displayToolTip, bool displayName = false)
{
//IL_005f: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Expected O, but got Unknown
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
GUILayout.BeginHorizontal(RGUI.Unexpanded);
if (displayName)
{
GUILayout.Label(name, RGUI.Unexpanded);
}
GUILayout.Space(10f);
string text = (displayToolTip ? "Press Delete to clear" : "");
bool flag = ((!isSettingKey) ? GUILayout.Button(new GUIContent(GetKeyDisplayString(), text), (GUILayoutOption[])(object)new GUILayoutOption[0]) : GUILayout.Button(new GUIContent("Press Any Key/Button", text), (GUILayoutOption[])(object)new GUILayoutOption[0]));
toolTipRect = GUILayoutUtility.GetLastRect();
GUILayout.EndHorizontal();
if (flag && !isSettingKey && !InputReader.IsBlocked)
{
((MonoBehaviour)UI.Instance).StartCoroutine(BindKey(this));
}
else
{
flag = false;
}
return flag;
}
public virtual bool OnGUI(bool displayToolTip, bool displayName, bool includeNameInside)
{
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: Expected O, but got Unknown
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0076: Expected O, but got Unknown
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
GUILayout.BeginHorizontal(RGUI.Unexpanded);
if (displayName)
{
GUILayout.Label(name, RGUI.Unexpanded);
GUILayout.Space(10f);
}
string text = (displayToolTip ? "Press Delete to clear" : "");
string text2 = (includeNameInside ? (name + ": ") : "");
bool flag = ((!isSettingKey) ? GUILayout.Button(new GUIContent(text2 + GetKeyDisplayString(), text), (GUILayoutOption[])(object)new GUILayoutOption[0]) : GUILayout.Button(new GUIContent(text2 + "Press Any Key/Button", text), (GUILayoutOption[])(object)new GUILayoutOption[0]));
toolTipRect = GUILayoutUtility.GetLastRect();
GUILayout.EndHorizontal();
if (flag && !isSettingKey && !InputReader.IsBlocked)
{
((MonoBehaviour)UI.Instance).StartCoroutine(BindKey(this));
}
else
{
flag = false;
}
return flag;
}
}
public class AllModKeyBindings
{
private static Dictionary<string, Dictionary<string, KeyBindingForPlayers>> AllKeyBindings;
public static KeyBindingForPlayers LoadKeyBinding(string modName, string keyName)
{
if (TryGetKeyBinding(modName, keyName, out var keybinding))
{
return keybinding;
}
return new KeyBindingForPlayers(modName, keyName);
}
public static void AddKeyBinding(KeyBindingForPlayers keybinding, string modId)
{
try
{
if (AllKeyBindings != null)
{
if (!AllKeyBindings.TryGetValue(modId, out var value))
{
value = new Dictionary<string, KeyBindingForPlayers>();
AllKeyBindings.Add(modId, value);
}
value.Add(keybinding.name, keybinding);
}
}
catch (Exception exception)
{
RocketMain.Logger.Exception(exception);
}
}
public static bool TryGetKeyBinding(string modName, string keyName, out KeyBindingForPlayers keybinding)
{
if (AllKeyBindings.TryGetValue(modName, out var value))
{
return value.TryGetValue(keyName, out keybinding);
}
keybinding = null;
return false;
}
public static bool TryGetAllKeyBindingsForMod(string modName, out Dictionary<string, KeyBindingForPlayers> modKeyBindings)
{
return AllKeyBindings.TryGetValue(modName, out modKeyBindings);
}
public static void ClearKeyBindingsForMod(string modName)
{
if (!TryGetAllKeyBindingsForMod(modName, out var modKeyBindings))
{
return;
}
foreach (KeyValuePair<string, KeyBindingForPlayers> item in modKeyBindings)
{
item.Value.ClearKey();
}
}
public static string ConvertToJson()
{
return JsonConvert.SerializeObject((object)AllKeyBindings, (Formatting)1);
}
public static bool ReadFromJson(string json)
{
try
{
AllKeyBindings = JsonConvert.DeserializeObject<Dictionary<string, Dictionary<string, KeyBindingForPlayers>>>(json);
return true;
}
catch (Exception exception)
{
RocketMain.Logger.Exception("Exception converting from JSON: ", exception);
return false;
}
}
public static void RecreateDictionary()
{
AllKeyBindings = new Dictionary<string, Dictionary<string, KeyBindingForPlayers>>();
}
}
[Serializable]
public class KeyBindingForPlayers
{
public string name;
protected KeyBinding player0;
protected KeyBinding player1;
protected KeyBinding player2;
protected KeyBinding player3;
[XmlIgnore]
public KeyBinding Player0
{
get
{
return player0;
}
set
{
player0 = value;
}
}
[XmlIgnore]
public KeyBinding Player1
{
get
{
return player1;
}
set
{
player1 = value;
}
}
[XmlIgnore]
public KeyBinding Player2
{
get
{
return player2;
}
set
{
player2 = value;
}
}
[XmlIgnore]
public KeyBinding Player3
{
get
{
return player3;
}
set
{
player3 = value;
}
}
public KeyBinding this[int index]
{
get
{
return index switch
{
0 => player0,
1 => player1,
2 => player2,
3 => player3,
_ => player0,
};
}
set
{
switch (index)
{
case 0:
player0 = value;
break;
case 1:
player1 = value;
break;
case 2:
player2 = value;
break;
case 3:
player3 = value;
break;
}
}
}
public KeyBindingForPlayers()
{
}
public KeyBindingForPlayers(string modId, string name)
{
this.name = name;
player0 = new KeyBinding(name);
player1 = new KeyBinding(name);
player2 = new KeyBinding(name);
player3 = new KeyBinding(name);
AllModKeyBindings.AddKeyBinding(this, modId);
}
public virtual void AssignKey(int player, KeyCode key)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
this[player].AssignKey(key);
}
public virtual void AssignKey(int player, string joystick, int direction)
{
this[player].AssignKey(joystick, direction);
}
public bool HasAnyKeysAssigned()
{
for (int i = 0; i < 4; i++)
{
if (this[i].HasKeyAssigned())
{
return true;
}
}
return false;
}
public bool HasKeysAssigned(int player)
{
if (player < 0 || player > 3)
{
return false;
}
return this[player].HasKeyAssigned();
}
public bool IsDown(int player)
{
if (player < 0 || player > 3)
{
return false;
}
return this[player].IsDown();
}
public bool PressedDown(int player)
{
if (player < 0 || player > 3)
{
return false;
}
return this[player].PressedDown();
}
public bool Released(int player)
{
if (player < 0 || player > 3)
{
return false;
}
return this[player].Released();
}
public void ClearKey(int player)
{
if (player >= 0 && player <= 3)
{
this[player].ClearKey();
}
}
public void ClearKey()
{
for (int i = 0; i < 4; i++)
{
this[i].ClearKey();
}
}
public bool OnGUI(out int player, bool displayToolTip = true)
{
//IL_001f: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_007c: Expected O, but got Unknown
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_0093: Unknown result type (might be due to invalid IL or missing references)
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
player = 0;
bool result = false;
try
{
GUILayout.BeginHorizontal(RGUI.Unexpanded);
GUILayout.Label(name, RGUI.Unexpanded);
Rect val = Rect.zero;
for (int i = 0; i < 4; i++)
{
GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[2]
{
GUILayout.ExpandHeight(false),
GUILayout.Width(200f)
});
RGUI.LabelCenteredHorizontally(new GUIContent("Player " + (i + 1)), GUI.skin.label, RGUI.Unexpanded);
bool flag = this[i].OnGUI(displayToolTip);
if (i == 0)
{
val = KeyBinding.toolTipRect;
((Rect)(ref val)).y = ((Rect)(ref val)).y + 17f;
}
GUILayout.EndVertical();
if (flag)
{
this[i].isSettingKey = true;
result = flag;
player = i;
break;
}
}
if (displayToolTip && GUI.tooltip != string.Empty)
{
GUI.Label(val, GUI.tooltip);
GUI.tooltip = string.Empty;
}
GUILayout.EndHorizontal();
}
catch (Exception exception)
{
RocketMain.Logger.Exception(exception);
}
return result;
}
public bool OnGUI(out int player, bool displayToolTip, bool includeToolTip, ref string previousToolTip, int playerToDisplay = -1, bool onlyOnePlayer = false, bool separateKeyName = true, bool fixedWidth = true)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0151: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Expected O, but got Unknown
//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
player = 0;
bool result = false;
try
{
GUILayout.BeginHorizontal(RGUI.Unexpanded);
if (separateKeyName)
{
GUILayout.Label(name, RGUI.Unexpanded);
}
Rect val = Rect.zero;
if (!onlyOnePlayer)
{
for (int i = 0; i < 4; i++)
{
if (fixedWidth)
{
GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[2]
{
GUILayout.ExpandHeight(false),
GUILayout.Width(200f)
});
}
else
{
GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(false) });
}
RGUI.LabelCenteredHorizontally(new GUIContent("Player " + (i + 1)), GUI.skin.label, RGUI.Unexpanded);
bool flag = this[i].OnGUI(includeToolTip, displayName: false, !separateKeyName);
if (i == 0)
{
val = KeyBinding.toolTipRect;
((Rect)(ref val)).y = ((Rect)(ref val)).y + 17f;
}
GUILayout.EndVertical();
if (flag)
{
this[i].isSettingKey = true;
result = flag;
player = i;
break;
}
}
}
else
{
if (fixedWidth)
{
GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[2]
{
GUILayout.ExpandHeight(false),
GUILayout.Width(200f)
});
}
else
{
GUILayout.BeginVertical((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandHeight(false) });
}
bool flag2 = this[playerToDisplay].OnGUI(includeToolTip, displayName: false, !separateKeyName);
val = KeyBinding.toolTipRect;
((Rect)(ref val)).y = ((Rect)(ref val)).y + 17f;
GUILayout.EndVertical();
if (flag2)
{
this[playerToDisplay].isSettingKey = true;
result = flag2;
player = playerToDisplay;
}
}
if (displayToolTip && GUI.tooltip != string.Empty && GUI.tooltip != previousToolTip)
{
GUI.Label(val, GUI.tooltip);
GUI.tooltip = string.Empty;
}
GUILayout.EndHorizontal();
}
catch (Exception exception)
{
RocketMain.Logger.Exception(exception);
}
return result;
}
}
public static class RGUI
{
public static GUILayoutOption[] Unexpanded => (GUILayoutOption[])(object)new GUILayoutOption[2]
{
GUILayout.ExpandHeight(false),
GUILayout.ExpandWidth(false)
};
public static int ArrowList(string[] StringsArray, int selected)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
GUIStyle style = new GUIStyle(GUIStyle.op_Implicit("button"));
GUIStyle style2 = new GUIStyle(GUIStyle.op_Implicit("button"));
GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
style = ChangeArrowStyle(style, selected > 0);
if (GUILayout.Button("<", style, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }) && selected > 0)
{
selected--;
}
GUILayout.Label(StringsArray[selected].ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
style2 = ChangeArrowStyle(style2, selected < StringsArray.Length - 1);
if (GUILayout.Button(">", style2, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }) && selected < StringsArray.Length - 1)
{
selected++;
}
GUILayout.EndHorizontal();
return selected;
}
public static int ArrowList(string[] StringsArray, int selected, float Width)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
GUIStyle style = new GUIStyle(GUIStyle.op_Implicit("button"));
GUIStyle style2 = new GUIStyle(GUIStyle.op_Implicit("button"));
GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(Width) });
style = ChangeArrowStyle(style, selected > 0);
if (GUILayout.Button("<", style, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }) && selected > 0)
{
selected--;
}
GUILayout.FlexibleSpace();
GUILayout.Label(StringsArray[selected].ToString(), (GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.FlexibleSpace();
style2 = ChangeArrowStyle(style2, selected < StringsArray.Length - 1);
if (GUILayout.Button(">", style2, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) }) && selected < StringsArray.Length - 1)
{
selected++;
}
GUILayout.EndHorizontal();
return selected;
}
public static int ArrowList(object[] ObjectsArray, int selected)
{
string[] stringsArray = ObjectsArray.Select((object obj) => obj.ToString()).ToArray();
return ArrowList(stringsArray, selected);
}
public static int ArrowList(object[] ObjectsArray, int selected, float Width)
{
string[] stringsArray = ObjectsArray.Select((object obj) => obj.ToString()).ToArray();
return ArrowList(stringsArray, selected, Width);
}
public static int Tab(string[] Strings, int Number, int Space, int TabWidth)
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Expected O, but got Unknown
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0020: Expected O, but got Unknown
GUIStyle val = new GUIStyle(GUIStyle.op_Implicit("button"));
GUIStyle val2 = new GUIStyle(GUIStyle.op_Implicit("button"));
val2.normal.background = val2.hover.background;
GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
for (int i = 0; i < Strings.Length; i++)
{
if (GUILayout.Button(Strings[i], (i == Number) ? val2 : val, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width((float)TabWidth) }))
{
return i;
}
GUILayout.Space((float)Space);
}
GUILayout.EndHorizontal();
return Number;
}
private static GUIStyle ChangeArrowStyle(GUIStyle Style, bool ToCheck)
{
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0009: Unknown result type (might be due to invalid IL or missing references)
//IL_0019: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
if (ToCheck)
{
Style.normal.textColor = Color.white;
Style.hover.textColor = Color.white;
Style.active.textColor = Color.white;
}
else
{
Style.normal.textColor = Color.gray;
Style.hover.textColor = Color.gray;
Style.active.textColor = Color.gray;
}
return Style;
}
public static void LabelCenteredHorizontally(GUIContent content, GUIStyle style = null, params GUILayoutOption[] options)
{
GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.FlexibleSpace();
GUILayout.Label(content, style ?? GUI.skin.label, options);
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
}
public static float HorizontalSlider(string text, float value, float minValue, float maxValue, float sliderWidth = 500f)
{
GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.Label(text, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
GUILayout.Label(value.ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
value = GUILayout.HorizontalSlider(value, minValue, maxValue, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MaxWidth(sliderWidth) });
GUILayout.EndHorizontal();
return value;
}
public static float HorizontalSlider(string text, string tooltip, float value, float minValue, float maxValue, float sliderWidth = 500f)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
GUILayout.BeginHorizontal(new GUIContent(string.Empty, tooltip), GUIStyle.none, (GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.Label(text, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
GUILayout.Label(value.ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
value = GUILayout.HorizontalSlider(value, minValue, maxValue, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MaxWidth(sliderWidth) });
GUILayout.EndHorizontal();
return value;
}
public static int HorizontalSliderInt(string text, int value, int minValue, int maxValue, float sliderWidth = 500f)
{
GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.Label(text, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
GUILayout.Label(value.ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
value = (int)GUILayout.HorizontalSlider((float)value, (float)minValue, (float)maxValue, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MaxWidth(sliderWidth) });
GUILayout.EndHorizontal();
return value;
}
public static int HorizontalSliderInt(string text, string tooltip, int value, int minValue, int maxValue, float sliderWidth = 500f)
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
GUILayout.BeginHorizontal(new GUIContent(string.Empty, tooltip), GUIStyle.none, (GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.Label(text, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
GUILayout.Label(value.ToString(), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(70f) });
value = (int)GUILayout.HorizontalSlider((float)value, (float)minValue, (float)maxValue, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MaxWidth(sliderWidth) });
GUILayout.EndHorizontal();
return value;
}
}
}
namespace RocketLib.UMM
{
internal static class Main
{
public static bool Enabled;
public static Harmony harmony;
public static ModEntry Mod;
public static Settings settings;
private static ILogger Logger => RocketMain.Logger;
private static bool Load(ModEntry modEntry)
{
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Expected O, but got Unknown
Mod = modEntry;
modEntry.OnToggle = OnToggle;
modEntry.OnGUI = ModUI.OnGui;
modEntry.OnSaveGUI = OnSaveGUI;
modEntry.OnUpdate = OnUpdate;
modEntry.CustomRequirements = MakeUSAColorOnBroforce();
settings = ModSettings.Load<Settings>(modEntry);
try
{
harmony = new Harmony(modEntry.Info.Id);
Assembly executingAssembly = Assembly.GetExecutingAssembly();
harmony.PatchAll(executingAssembly);
}
catch (Exception ex)
{
Mod.Logger.LogException("Error while applying RocketLib patches: ", ex);
}
try
{
RocketMain.Load(Mod);
if (settings.ShowLogOnScreen)
{
ScreenLogger.Load();
}
}
catch (Exception ex2)
{
Mod.Logger.LogException("Error while Loading RocketLib:", ex2);
}
try
{
RocketLib.UMM.Mod.Load();
}
catch (Exception ex3)
{
Mod.Logger.LogException(ex3);
}
ModOptionsMenu.Initialize();
return true;
}
private static void RegisterTestMenus()
{
try
{
MenuRegistry.RegisterMenu<VanillaSubmenuExample>("TEST MAINMENU", TargetMenu.MainMenu, PositionMode.After, "START");
MenuRegistry.RegisterMenu<VanillaSubmenuExample>("TEST OPTIONS MAINMENU", TargetMenu.OptionsMenu, PositionMode.After, "CONFIGURE CONTROLS");
MenuRegistry.RegisterMenu<VanillaSubmenuExample>("TEST PAUSEMENU", TargetMenu.PauseMenu, PositionMode.After, "RESUME GAME");
MenuRegistry.RegisterMenu<VanillaSubmenuExample>("TEST OPTIONS PAUSEMENU", TargetMenu.InGameOptionsMenu, PositionMode.After, "BACK");
Logger.Log("Test menus registered successfully");
}
catch (Exception ex)
{
Logger.Error("Failed to register test menus: " + ex.ToString());
}
}
private static string MakeUSAColorOnBroforce()
{
string text = "Broforce";
string text2 = string.Empty;
for (int i = 0; i < 3; i++)
{
if (i == 0)
{
text2 = "<color=\"#1C59FE\">";
}
text2 += text[i];
if (i == 2)
{
text2 += "</color>";
}
}
for (int j = 3; j < text.Length; j++)
{
text2 = ((j % 2 != 0) ? (text2 + "<color=\"white\">" + text[j] + "</color>") : (text2 + "<color=\"red\">" + text[j] + "</color>"));
}
return text2;
}
private static void OnSaveGUI(ModEntry modEntry)
{
((ModSettings)settings).Save(modEntry);
}
private static void OnUpdate(ModEntry modEntry, float dt)
{
if (!LevelEditorGUI.IsActive)
{
ShowMouseController.ShowMouse = false;
}
Cursor.lockState = (CursorLockMode)0;
RocketLib.UMM.Mod.Update();
}
private static bool OnToggle(ModEntry modEntry, bool value)
{
Enabled = value;
return true;
}
}
public class Settings : ModSettings
{
public bool ShowLogOnScreen;
public bool ShowManagerLog = true;
public float LogTimer = 3f;
public int FontSize = 13;
public bool ShowDebugLogs;
public override void Save(ModEntry modEntry)
{
Mod.save.Save();
ModSettings.Save<Settings>(this, modEntry);
}
}
internal static class Mod
{
public static ModSave save;
public static Settings Setting => Main.settings;
public static void Load()
{
save = ModSave.Load();
save.Initialize();
ModUI.Initialize();
}
public static void Update()
{
CheckGesture(save.gesture0, (Gestures)1);
CheckGesture(save.gesture1, (Gestures)2);
CheckGesture(save.gesture2, (Gestures)3);
CheckGesture(save.gesture3, (Gestures)5);
CheckGesture(save.gesture4, (Gestures)6);
CheckGesture(save.gesture5, (Gestures)7);
}
private static void CheckGesture(KeyBindingForPlayers bindings, Gestures gesture)
{
//IL_0023: Unknown result type (might be due to invalid IL or missing references)
for (int i = 0; i < 3; i++)
{
if (bindings.IsDown(i) && HeroController.PlayerIsAlive(i))
{
TestVanDammeAnim character = HeroController.players[i].character;
character.SetGestureAnimation(gesture);
}
}
}
}
public class ModSave
{
public KeyBindingForPlayers gesture0;
public KeyBindingForPlayers gesture1;
public KeyBindingForPlayers gesture2;
public KeyBindingForPlayers gesture3;
public KeyBindingForPlayers gesture4;
public KeyBindingForPlayers gesture5;
public KeyBindingForPlayers gesture6;
public static string SavePath => Path.Combine(Main.Mod.Path, "Keybindings.json");
public void Save()
{
string contents = AllModKeyBindings.ConvertToJson();
File.WriteAllText(SavePath, contents);
}
public static ModSave Load()
{
try
{
if (File.Exists(SavePath))
{
AllModKeyBindings.ReadFromJson(File.ReadAllText(SavePath));
ModSave modSave = new ModSave();
AllModKeyBindings.TryGetAllKeyBindingsForMod(Main.Mod.Info.Id, out var modKeyBindings);
if (modKeyBindings != null)
{
modKeyBindings.TryGetValue("Gesture 0", out modSave.gesture0);
modKeyBindings.TryGetValue("Gesture 1", out modSave.gesture1);
modKeyBindings.TryGetValue("Gesture 2", out modSave.gesture2);
modKeyBindings.TryGetValue("Gesture 3", out modSave.gesture3);
modKeyBindings.TryGetValue("Gesture 4", out modSave.gesture4);
modKeyBindings.TryGetValue("Gesture 5", out modSave.gesture5);
modKeyBindings.TryGetValue("Gesture 6", out modSave.gesture6);
}
return modSave;
}
}
catch
{
}
AllModKeyBindings.RecreateDictionary();
return new ModSave();
}
public void Initialize()
{
try
{
if (gesture0 == null)
{
gesture0 = new KeyBindingForPlayers(Main.Mod.Info.Id, "Gesture 0");
}
if (gesture1 == null)
{
gesture1 = new KeyBindingForPlayers(Main.Mod.Info.Id, "Gesture 1");
}
if (gesture2 == null)
{
gesture2 = new KeyBindingForPlayers(Main.Mod.Info.Id, "Gesture 2");
}
if (gesture3 == null)
{
gesture3 = new KeyBindingForPlayers(Main.Mod.Info.Id, "Gesture 3");
}
if (gesture4 == null)
{
gesture4 = new KeyBindingForPlayers(Main.Mod.Info.Id, "Gesture 4");
}
if (gesture5 == null)
{
gesture5 = new KeyBindingForPlayers(Main.Mod.Info.Id, "Gesture 5");
}
if (gesture6 == null)
{
gesture6 = new KeyBindingForPlayers(Main.Mod.Info.Id, "Gesture 6");
}
}
catch (Exception exception)
{
RocketMain.Logger.Exception(exception);
}
}
}
internal static class ModUI
{
public const int KEYBIND_WINDOW_ID = -1;
private static readonly string[] _tabsName = new string[5] { "<color=\"yellow\">Main</color>", "Screen Logger", "Scene Loader", "Log", "Key Bindings" };
private static readonly Action[] _tabsAction = new Action[5] { MainGUI, ScreenLoggerGUI, LoadSceneGUI, LogGUI, KeyBindings };
private static readonly GUIStyle _logStyle = new GUIStyle();
private static string _sceneStr = string.Empty;
private static Vector2 _scrollViewVector = Vector2.zero;
private static int _tabSelected = 0;
private static readonly GUIStyle _testBtnStyle = new GUIStyle(GUIStyle.op_Implicit("button"));
private const string _changeKeyMessage = "Press Any Key";
private static GUIStyle keybindModStyle;
public static Dictionary<string, KeyBindingForPlayers> modKeyBindings;
private static Settings settings => Main.settings;
public static void Initialize()
{
//IL_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Expected O, but got Unknown
//IL_0028: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Expected O, but got Unknown
_testBtnStyle.normal.textColor = Color.yellow;
keybindModStyle = new GUIStyle();
keybindModStyle.normal.background = (Texture2D)CreateTexture.WithColor(Extensions.SetAlpha(Color.gray, 0.5f));
}
public static void OnGui(ModEntry modEntry)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Unknown result type (might be due to invalid IL or missing references)
_tabSelected = RGUI.Tab(_tabsName, _tabSelected, 10, 110);
GUILayout.Space(30f);
Rect lastRect = GUILayoutUtility.GetLastRect();
_tabsAction[_tabSelected]();
GUI.Label(lastRect, GUI.tooltip);
}
public static void MainGUI()
{
GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), (GUILayoutOption[])(object)new GUILayoutOption[0]);
if (settings.ShowLogOnScreen != (settings.ShowLogOnScreen = GUILayout.Toggle(settings.ShowLogOnScreen, "Enable OnScreenLog", (GUILayoutOption[])(object)new GUILayoutOption[0])) && settings.ShowLogOnScreen)
{
ScreenLogger.Load();
}
GUILayout.EndVertical();
}
private static void ScreenLoggerGUI()
{
//IL_008b: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Expected O, but got Unknown
GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), (GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
if (GUILayout.Button("Clear Log on screen", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) }))
{
ScreenLogger.Instance.Clear();
}
GUILayout.FlexibleSpace();
GUILayout.EndHorizontal();
Main.settings.ShowDebugLogs = GUILayout.Toggle(Main.settings.ShowDebugLogs, "Show Debug logs", (GUILayoutOption[])(object)new GUILayoutOption[0]);
settings.ShowManagerLog = GUILayout.Toggle(settings.ShowManagerLog, new GUIContent("Show Unity Mod Manager Log"), (GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.Label("Time before log disappear : " + settings.LogTimer, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
settings.LogTimer = (int)GUILayout.HorizontalScrollbar(settings.LogTimer, 1f, 1f, 11f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MaxWidth(200f) });
GUILayout.EndHorizontal();
GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.Label("Log Font Size : " + settings.FontSize, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
settings.FontSize = (int)GUILayout.HorizontalScrollbar((float)settings.FontSize, 1f, 1f, 25f, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.MaxWidth(200f) });
GUILayout.EndHorizontal();
GUILayout.EndVertical();
}
private static void LoadSceneGUI()
{
GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), (GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.BeginHorizontal((GUILayoutOption[])(object)new GUILayoutOption[0]);
_sceneStr = GUILayout.TextField(_sceneStr, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(200f) });
GUILayout.Space(10f);
if (GUILayout.Button("Load Scene", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) }))
{
try
{
SceneLoader.LoadScene(_sceneStr, (LoadSceneMode)0);
}
catch (Exception exception)
{
RocketMain.Logger.Exception(exception);
}
}
GUILayout.EndHorizontal();
GUILayout.Space(10f);
if (GUILayout.Button("Load Main Menu", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(150f) }))
{
try
{
SceneLoader.LoadScene("MainMenu", (LoadSceneMode)0);
}
catch (Exception exception2)
{
RocketMain.Logger.Exception(exception2);
}
}
GUILayout.EndVertical();
}
private static void LogGUI()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_002d: Unknown result type (might be due to invalid IL or missing references)
//IL_0032: Unknown result type (might be due to invalid IL or missing references)
//IL_005c: Unknown result type (might be due to invalid IL or missing references)
GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), (GUILayoutOption[])(object)new GUILayoutOption[0]);
_scrollViewVector = GUILayout.BeginScrollView(_scrollViewVector, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(250f) });
foreach (string fullLog in ScreenLogger.Instance.FullLogList)
{
_logStyle.normal.textColor = ScreenLogger.WhichColor(fullLog);
GUILayout.Label(fullLog, _logStyle, (GUILayoutOption[])(object)new GUILayoutOption[0]);
GUILayout.Space(5f);
}
GUILayout.EndScrollView();
GUILayout.EndVertical();
}
private static void KeyBindings()
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_003e: Expected O, but got Unknown
try
{
int player = 0;
GUILayout.BeginVertical(GUIStyle.op_Implicit("box"), (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.ExpandWidth(false) });
RGUI.LabelCenteredHorizontally(new GUIContent("RocketLib"), GUI.skin.label, RGUI.Unexpanded);
if (modKeyBindings == null)
{
AllModKeyBindings.TryGetAllKeyBindingsForMod("RocketLib", out modKeyBindings);
}
if (modKeyBindings != null)
{
foreach (KeyValuePair<string, KeyBindingForPlayers> modKeyBinding in modKeyBindings)
{
modKeyBinding.Value.OnGUI(out player);
GUILayout.Space(30f);
}
}
if (GUILayout.Button("Clear All", (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Width(100f) }))
{
AllModKeyBindings.ClearKeyBindingsForMod("RocketLib");
}
GUILayout.EndVertical();
GUILayout.Space(30f);
}
catch (Exception exception)
{
RocketMain.Logger.Exception(exception);
}
}
}
[HarmonyPatch(typeof(UI), "Start")]
internal static class UnityModManager_UI_Start_Patch
{
public static void Postfix(UI __instance)
{
RocketLibUtils.MakeObjectUnpausable(((Component)__instance).gameObject);
}
}
[HarmonyPatch(typeof(Startup), "Update")]
internal static class Startup_Update_Patch
{
public static void Prefix(Startup __instance)
{
if (Main.Enabled)
{
RocketLibUtils.MakeObjectUnpausable("RuntimeUnityEditor");
}
}
}
}
namespace RocketLib.Menus.Elements
{
public abstract class LayoutElement
{
private readonly string id;
private bool _isVisible;
private bool _isPositioned;
protected GameObject gameObject;
protected Transform menuTransform;
public string Id => id;
public string Name { get; set; }
public LayoutContainer Parent { get; set; }
public SizeMode WidthMode { get; set; }
public SizeMode HeightMode { get; set; }
public float Width { get; set; }
public float Height { get; set; }
public Vector2 MinSize { get; set; }
public Vector2 MaxSize { get; set; }
public HorizontalAlignment? HorizontalAlignmentOverride { get; set; }
public VerticalAlignment? VerticalAlignmentOverride { get; set; }
public Vector2 ActualPosition { get; set; }
public Vector2 ActualSize { get; set; }
public bool IsVisible
{
get
{
return _isVisible;
}
set
{
_isVisible = value;
OnVisibilityChanged();
}
}
public bool IsPositioned
{
get
{
return _isPositioned;
}
set
{
_isPositioned = value;
OnIsPositionedChanged();
}
}
public bool IsVisibleAndPositioned
{
get
{
if (IsVisible)
{
return IsPositioned;
}
return false;
}
set
{
bool isVisible = (IsPositioned = value);
IsVisible = isVisible;
}
}
public bool IsEnabled { get; set; }
public bool IsFocusable { get; set; }
public bool IsFocused { get; set; }
public object Tag { get; set; }
protected LayoutElement(string name)
{
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
id = Guid.NewGuid().ToString();
Name = name;
WidthMode = SizeMode.Fill;
HeightMode = SizeMode.Fill;
Width = 1f;
Height = 1f;
MinSize = Vector2.zero;
MaxSize = Vector2.zero;
_isVisible = true;
_isPositioned = true;
IsEnabled = true;
IsFocusable = false;
IsFocused = false;
}
public virtual void UpdateLayout()
{
}
public virtual float GetPreferredWidth()
{
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
switch (WidthMode)
{
case SizeMode.Fixed:
return Width;
case SizeMode.Percentage:
if (Parent == null)
{
return Width;
}
return Width / 100f * Parent.ActualSize.x;
case SizeMode.Auto:
return Width;
default:
return 0f;
}
}
public virtual float GetPreferredHeight()
{
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
switch (HeightMode)
{
case SizeMode.Fixed:
return Height;
case SizeMode.Percentage:
if (Parent == null)
{
return Height;
}
return Height / 100f * Parent.ActualSize.y;
case SizeMode.Auto:
return Height;
default:
return 0f;
}
}
public virtual void SetMenuTransform(Transform transform)
{
menuTransform = transform;
if ((Object)(object)gameObject != (Object)null && (Object)(object)menuTransform != (Object)null)
{
gameObject.transform.SetParentAndResetScale(menuTransform);
}
}
public abstract void Render();
public virtual void Cleanup()
{
if ((Object)(object)gameObject != (Object)null)
{
Object.Destroy((Object)(object)gameObject);
gameObject = null;
}
}
public virtual bool ContainsPoint(Vector2 point)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0013: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002b: Unknown result type (might be due to invalid IL or missing references)
//IL_0039: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_004e: Unknown result type (might be due to invalid IL or missing references)
//IL_0055: Unknown result type (might be due to invalid IL or missing references)
//IL_0063: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
float num = ActualSize.x / 2f;
float num2 = ActualSize.y / 2f;
if (point.x >= ActualPosition.x - num && point.x <= ActualPosition.x + num && point.y >= ActualPosition.y - num2)
{
return point.y <= ActualPosition.y + num2;
}
return false;
}
public virtual LayoutElement GetElementAt(Vector2 position)
{
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
if (!IsVisible || !IsEnabled)
{
return null;
}
if (IsFocusable && ContainsPoint(position))
{
return this;
}
return null;
}
public virtual List<LayoutElement> GetFocusableElements()
{
List<LayoutElement> list = new List<LayoutElement>();
if (!IsEnabled)
{
return list;
}
if (IsFocusable)
{
list.Add(this);
}
return list;
}
public virtual Rect GetBounds()
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_001e: Unknown result type (might be due to invalid IL or missing references)
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_003b: Unknown result type (might be due to invalid IL or missing references)
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Unknown result type (might be due to invalid IL or missing references)
return new Rect(ActualPosition.x - ActualSize.x / 2f, ActualPosition.y - ActualSize.y / 2f, ActualSize.x, ActualSize.y);
}
public virtual void OnFocusGained()
{
IsFocused = true;
}
public virtual void OnFocusLost()
{
IsFocused = false;
}
public virtual void OnActivated()
{
}
public virtual void OnVisibilityChanged()
{
}
public virtual void OnIsPositionedChanged()
{
}
public LayoutElement FindById(string id)
{
if (Id == id)
{
return this;
}
if (this is LayoutContainer layoutContainer)
{
foreach (LayoutElement child in layoutContainer.Children)
{
LayoutElement layoutElement = child.FindById(id);
if (layoutElement != null)
{
return layoutElement;
}
}
}
return null;
}
public LayoutElement FindByName(string name)
{
if (Name == name)
{
return this;
}
if (this is LayoutContainer layoutContainer)
{
foreach (LayoutElement child in layoutContainer.Children)
{
LayoutElement layoutElement = child.FindByName(name);
if (layoutElement != null)
{
return layoutElement;
}
}
}
return null;
}
public T FindByType<T>() where T : LayoutElement
{
if (this is T)
{
return (T)this;
}
if (this is LayoutContainer layoutContainer)
{
foreach (LayoutElement child in layoutContainer.Children)
{
T val = child.FindByType<T>();
if (val != null)
{
return val;
}
}
}
return null;
}
public List<T> FindAllByType<T>() where T : LayoutElement
{
List<T> list = new List<T>();
if (this is T)
{
list.Add((T)this);
}
if (this is LayoutContainer layoutContainer)
{
foreach (LayoutElement child in layoutContainer.Children)
{
list.AddRange(child.FindAllByType<T>());
}
}
return list;
}
}
public class ImageElement : LayoutElement
{
public enum ImageScaleMode
{
None,
Stretch,
Fit,
Fill
}
private GameObject spriteGO;
private SpriteSM spriteSM;
private MeshRenderer meshRenderer;
private Material _material;
private bool _needsUpdate = true;
private Material _imageMaterial;
private Texture2D _texture;
private Color _tint = Color.white;
public Material ImageMaterial
{
get
{
return _imageMaterial;
}
set
{
_imageMaterial = value;
_needsUpdate = true;
if ((Object)(object)spriteSM != (Object)null)
{
UpdateSpriteSM();
}
}
}
public Texture2D Texture
{
get
{
return _texture;
}
set
{
_texture = value;
_needsUpdate = true;
if ((Object)(object)spriteSM != (Object)null)
{
UpdateSpriteSM();
}
}
}
public ImageScaleMode ScaleMode { get; set; } = ImageScaleMode.Fit;
public Color Tint
{
get
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return _tint;
}
set
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
_tint = value;
UpdateTint();
}
}
public int PixelsPerUnit { get; set; } = 1;
public Vector2? LowerLeftPixel { get; set; }
public Vector2? PixelDimensions { get; set; }
public Vector2? SpriteOffset { get; set; }
public ImageElement(string name)
: base(name)
{
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
base.IsFocusable = false;
}
public override void Render()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001f: Expected O, but got Unknown
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Unknown result type (might be due to invalid IL or missing references)
//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
//IL_00df: Expected O, but got Unknown
//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
//IL_0156: Unknown result type (might be due to invalid IL or missing references)
//IL_0162: Unknown result type (might be due to invalid IL or missing references)
//IL_016d: Unknown result type (might be due to invalid IL or missing references)
//IL_0172: Unknown result type (might be due to invalid IL or missing references)
try
{
if ((Object)(object)gameObject == (Object)null)
{
gameObject = new GameObject(base.Name);
if ((Object)(object)menuTransform != (Object)null)
{
gameObject.transform.SetParentAndResetScale(menuTransform);
}
}
if (!((Object)(object)gameObject != (Object)null))
{
return;
}
if (!base.IsVisible)
{
gameObject.SetActive(false);
return;
}
gameObject.transform.position = Vector2.op_Implicit(base.ActualPosition);
if ((Object)(object)spriteGO == (Object)null)
{
try
{
spriteGO = new GameObject("SpriteSM", new Type[3]
{
typeof(MeshRenderer),
typeof(MeshFilter),
typeof(SpriteSM)
});
spriteGO.transform.SetParentAndResetScale(gameObject.transform, Vector3.zero);
spriteSM = spriteGO.GetComponent<SpriteSM>();
meshRenderer = spriteGO.GetComponent<MeshRenderer>();
if ((Object)(object)meshRenderer != (Object)null)
{
((Renderer)meshRenderer).sortingOrder = 100;
}
if ((Object)(object)spriteSM != (Object)null)
{
((SpriteBase)spriteSM).plane = (SPRITE_PLANE)0;
((SpriteBase)spriteSM).anchor = (ANCHOR_METHOD)4;
((SpriteBase)spriteSM).offset = Vector3.zero;
}
if (_needsUpdate)
{
UpdateSpriteSM();
}
}
catch (Exception)
{
}
}
gameObject.SetActive(true);
}
catch (Exception)
{
}
}
private void UpdateSpriteSM()
{
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_0077: Expected O, but got Unknown
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
//IL_00f0: Expected O, but got Unknown
if ((Object)(object)spriteSM == (Object)null || (Object)(object)meshRenderer == (Object)null)
{
return;
}
if ((Object)(object)_imageMaterial != (Object)null)
{
((Renderer)meshRenderer).material = _imageMaterial;
_material = _imageMaterial;
Texture mainTexture = _imageMaterial.mainTexture;
if ((Object)(object)mainTexture != (Object)null && mainTexture is Texture2D)
{
SetupSpriteFromTexture((Texture2D)mainTexture);
}
}
else if ((Object)(object)_texture != (Object)null)
{
if ((Object)(object)_material == (Object)null)
{
Shader val = Shader.Find("Sprites/Default");
if ((Object)(object)val == (Object)null)
{
val = Shader.Find("Unlit/Texture");
}
if ((Object)(object)val == (Object)null)
{
Material sharedMaterial = ((Renderer)meshRenderer).sharedMaterial;
val = ((sharedMaterial != null) ? sharedMaterial.shader : null);
}
if ((Object)(object)val != (Object)null)
{
_material = new Material(val);
}
}
if ((Object)(object)_material != (Object)null)
{
_material.mainTexture = (Texture)(object)_texture;
((Renderer)meshRenderer).material = _material;
SetupSpriteFromTexture(_texture);
}
}
UpdateTint();
_needsUpdate = false;
}
private void SetupSpriteFromTexture(Texture2D texture)
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
//IL_003a: Unknown result type (might be due to invalid IL or missing references)
//IL_0048: Unknown result type (might be due to invalid IL or missing references)
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_006b: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Unknown result type (might be due to invalid IL or missing references)
//IL_0080: Unknown result type (might be due to invalid IL or missing references)
//IL_0081: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Unknown result type (might be due to invalid IL or missing references)
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)spriteSM == (Object)null) && !((Object)(object)texture == (Object)null))
{
spriteSM.lowerLeftPixel = (Vector2)(((??)LowerLeftPixel) ?? new Vector2(0f, (float)((Texture)texture).height));
Vector2 val = (Vector2)(((??)PixelDimensions) ?? new Vector2((float)((Texture)texture).width, (float)((Texture)texture).height));
spriteSM.pixelDimensions = val;
float width = val.x / (float)PixelsPerUnit;
float height = val.y / (float)PixelsPerUnit;
((SpriteBase)spriteSM).width = width;
((SpriteBase)spriteSM).height = height;
((SpriteBase)spriteSM).offset = Vector2.op_Implicit((Vector2)(((??)SpriteOffset) ?? new Vector2(0f, 0f)));
spriteSM.SetFieldValue<Texture2D>("texture", texture);
((SpriteBase)spriteSM).CalcUVs();
((SpriteBase)spriteSM).UpdateUVs();
ApplyScaling();
}
}
private void UpdateTint()
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)spriteSM != (Object)null)
{
((SpriteBase)spriteSM).SetColor(_tint);
}
}
private void ApplyScaling()
{
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0089: Unknown result type (might be due to invalid IL or missing references)
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0099: Unknown result type (might be due to invalid IL or missing references)
//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)spriteSM == (Object)null)
{
return;
}
if ((Object)(object)_texture == (Object)null)
{
Material imageMaterial = _imageMaterial;
if ((Object)(object)((imageMaterial != null) ? imageMaterial.mainTexture : null) == (Object)null)
{
return;
}
}
Texture2D val = (Texture2D)(((object)_texture) ?? ((object)/*isinst with value type is only supported in some contexts*/));
if ((Object)(object)val == (Object)null)
{
return;
}
Vector2 val2 = (Vector2)(((??)PixelDimensions) ?? new Vector2((float)((Texture)val).width, (float)((Texture)val).height));
float num = val2.x / (float)PixelsPerUnit;
float num2 = val2.y / (float)PixelsPerUnit;
if (!(num <= 0f) && !(num2 <= 0f))
{
float x = base.ActualSize.x;
float y = base.ActualSize.y;
float width = num;
float height = num2;
switch (ScaleMode)
{
case ImageScaleMode.Stretch:
width = x;
height = y;
break;
case ImageScaleMode.Fit:
{
float num4 = Mathf.Min(x / num, y / num2);
width = num * num4;
height = num2 * num4;
break;
}
case ImageScaleMode.Fill:
{
float num3 = Mathf.Max(x / num, y / num2);
width = num * num3;
height = num2 * num3;
break;
}
}
((SpriteBase)spriteSM).width = width;
((SpriteBase)spriteSM).height = height;
}
}
public override void UpdateLayout()
{
base.UpdateLayout();
if ((Object)(object)spriteSM != (Object)null && ((Object)(object)_texture != (Object)null || (Object)(object)_imageMaterial != (Object)null))
{
ApplyScaling();
}
}
public override void Cleanup()
{
if ((Object)(object)_material != (Object)null && (Object)(object)_imageMaterial == (Object)null)
{
Object.Destroy((Object)(object)_material);
_material = null;
}
if ((Object)(object)spriteGO != (Object)null)
{
Object.Destroy((Object)(object)spriteGO);
spriteGO = null;
spriteSM = null;
meshRenderer = null;
}
base.Cleanup();
}
}
public class TextElement : LayoutElement
{
private string _text = "Text";
private Color _textColor = Color.white;
private float _fontSize = 20f;
private BroforceFont _font;
private TextMesh textMesh;
private float cachedAutoWidth = 100f;
private bool boundsAvailable;
private bool visualNeedsUpdate = true;
public string Text
{
get
{
return _text;
}
set
{
if (_text != value)
{
_text = value;
boundsAvailable = false;
visualNeedsUpdate = true;
}
}
}
public Color TextColor
{
get
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
return _textColor;
}
set
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000f: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
if (_textColor != value)
{
_textColor = value;
visualNeedsUpdate = true;
}
}
}
public float FontSize
{
get
{
return _fontSize;
}
set
{
if (_fontSize != value)
{
_fontSize = value;
boundsAvailable = false;
visualNeedsUpdate = true;
}
}
}
public BroforceFont Font
{
get
{
return _font;
}
set
{
if (_font != value)
{
_font = value;
boundsAvailable = false;
visualNeedsUpdate = true;
}
}
}
public TextElement(string name)
: base(name)
{
//IL_000c: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
base.IsFocusable = false;
base.WidthMode = SizeMode.Fill;
base.HeightMode = SizeMode.Fixed;
base.Width = 1f;
base.Height = 30f;
}
public override void Render()
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might be due to invalid IL or missing references)
//IL_0075: Unknown result type (might be due to invalid IL or missing references)
//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
if ((Object)(object)gameObject == (Object)null)
{
CreateTextGameObject();
}
if (!((Object)(object)gameObject != (Object)null))
{
return;
}
if (!base.IsVisible)
{
gameObject.SetActive(false);
return;
}
gameObject.transform.localPosition = new Vector3(base.ActualPosition.x, base.ActualPosition.y, -1f);
gameObject.transform.localScale = Vector3.one;
if ((Object)(object)textMesh != (Object)null && visualNeedsUpdate)
{
textMesh.text = Text;
textMesh.color = TextColor;
FontManager.ApplyFont(textMesh, Font, FontSize);
visualNeedsUpdate = false;
}
gameObject.SetActive(true);
}
private void CreateTextGameObject()
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0011: Expected O, but got Unknown
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
gameObject = new GameObject(base.Name);
gameObject.layer = LayerMask.NameToLayer("UI");
if ((Object)(object)menuTransform != (Object)null)
{
gameObject.transform.SetParent(menuTransform, false);
}
MeshRenderer val = gameObject.AddComponent<MeshRenderer>();
textMesh = gameObject.AddComponent<TextMesh>();
textMesh.text = Text;
textMesh.anchor = (TextAnchor)4;
textMesh.alignment = (TextAlignment)1;
textMesh.color = TextColor;
FontManager.ApplyFont(textMesh, Font, FontSize);
((Renderer)val).sortingOrder = -10;
}
private void MeasureAutoWidth()
{
if (!boundsAvailable)
{
cachedAutoWidth = FontManager.CalculateTextWidth(Font, Text, FontSize);
boundsAvailable = true;
}
}
public override float GetPreferredWidth()
{
if (base.WidthMode == SizeMode.Auto)
{
if (!boundsAvailable)
{
MeasureAutoWidth();
}
return cachedAutoWidth;
}
return base.GetPreferredWidth();
}
public override float GetPreferredHeight()
{
if (base.HeightMode == SizeMode.Auto)
{
return MeasureTextHeight();
}
return base.GetPreferredHeight();
}
private float MeasureTextHeight()
{
return FontManager.CalculateTextHeight(Font, Text, FontSize);
}
public override void Cleanup()
{
textMesh = null;
base.Cleanup();
}
}
public class ActionButton : LayoutElement
{
private string _text = "Button";
private TextMesh textMesh;
private bool boundsAvailable;
private float cachedAutoWidth = 200f;
private readonly float buttonPadding = 40f;
public string Text
{
get
{
return _text;
}
set
{
if (_text != value)
{
_text = value;
boundsAvailable = false;
}
}
}
public float FontSize { get; set; }
public Action OnClick { get; set; }
public ActionButton(string name)
: base(name)
{
_text = "Button";
FontSize = 3f;
base.IsFocusable = true;
base.WidthMode = SizeMode.Fixed;
base.HeightMode = SizeMode.Fixed;
base.Width = 200f;
base.Height = 40f;
}
public override void Render()
{
//IL_0046: Unknown result type (might be due to invalid IL or missing references)
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0060: Unknown result type (might