using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Net.WebSockets;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Archipelago.MultiClient.Net.Colors;
using Archipelago.MultiClient.Net.ConcurrentCollection;
using Archipelago.MultiClient.Net.Converters;
using Archipelago.MultiClient.Net.DataPackage;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Exceptions;
using Archipelago.MultiClient.Net.Extensions;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.MessageLog.Messages;
using Archipelago.MultiClient.Net.MessageLog.Parts;
using Archipelago.MultiClient.Net.Models;
using Archipelago.MultiClient.Net.Packets;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: ComVisible(false)]
[assembly: Guid("35a803ad-85ed-42e9-b1e3-c6b72096f0c1")]
[assembly: InternalsVisibleTo("Archipelago.MultiClient.Net.Tests")]
[assembly: InternalsVisibleTo("DynamicProxyGenAssembly2")]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("Jarno Westhof, Hussein Farran, Zach Parks")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("Copyright © 2025")]
[assembly: AssemblyDescription("A client library for use with .NET based prog-langs for interfacing with Archipelago hosts.")]
[assembly: AssemblyFileVersion("6.6.1.0")]
[assembly: AssemblyInformationalVersion("6.6.1+dda0939d319f6671048f879688c4b2ab5cde40d4")]
[assembly: AssemblyProduct("Archipelago.MultiClient.Net")]
[assembly: AssemblyTitle("Archipelago.MultiClient.Net")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/ArchipelagoMW/Archipelago.MultiClient.Net")]
[assembly: AssemblyVersion("6.6.1.0")]
internal interface IConcurrentHashSet<T>
{
bool TryAdd(T item);
bool Contains(T item);
void UnionWith(T[] otherSet);
T[] ToArray();
ReadOnlyCollection<T> AsToReadOnlyCollection();
ReadOnlyCollection<T> AsToReadOnlyCollectionExcept(IConcurrentHashSet<T> otherSet);
}
public class AttemptingStringEnumConverter : StringEnumConverter
{
public AttemptingStringEnumConverter()
{
}
public AttemptingStringEnumConverter(Type namingStrategyType)
: base(namingStrategyType)
{
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
try
{
return ((StringEnumConverter)this).ReadJson(reader, objectType, existingValue, serializer);
}
catch (JsonSerializationException)
{
return objectType.IsValueType ? Activator.CreateInstance(objectType) : null;
}
}
}
namespace Archipelago.MultiClient.Net
{
[Serializable]
public abstract class ArchipelagoPacketBase
{
[JsonIgnore]
internal JObject jobject;
[JsonProperty("cmd")]
[JsonConverter(typeof(StringEnumConverter))]
public abstract ArchipelagoPacketType PacketType { get; }
public JObject ToJObject()
{
return jobject;
}
}
public interface IArchipelagoSession : IArchipelagoSessionActions
{
IArchipelagoSocketHelper Socket { get; }
IReceivedItemsHelper Items { get; }
ILocationCheckHelper Locations { get; }
IPlayerHelper Players { get; }
IDataStorageHelper DataStorage { get; }
IConnectionInfoProvider ConnectionInfo { get; }
IRoomStateHelper RoomState { get; }
IMessageLogHelper MessageLog { get; }
Task<RoomInfoPacket> ConnectAsync();
Task<LoginResult> LoginAsync(string game, string name, ItemsHandlingFlags itemsHandlingFlags, Version version = null, string[] tags = null, string uuid = null, string password = null, bool requestSlotData = true);
LoginResult TryConnectAndLogin(string game, string name, ItemsHandlingFlags itemsHandlingFlags, Version version = null, string[] tags = null, string uuid = null, string password = null, bool requestSlotData = true);
}
public class ArchipelagoSession : IArchipelagoSession, IArchipelagoSessionActions
{
private const int ArchipelagoConnectionTimeoutInSeconds = 4;
private ConnectionInfoHelper connectionInfo;
private TaskCompletionSource<LoginResult> loginResultTask = new TaskCompletionSource<LoginResult>();
private TaskCompletionSource<RoomInfoPacket> roomInfoPacketTask = new TaskCompletionSource<RoomInfoPacket>();
public IArchipelagoSocketHelper Socket { get; }
public IReceivedItemsHelper Items { get; }
public ILocationCheckHelper Locations { get; }
public IPlayerHelper Players { get; }
public IDataStorageHelper DataStorage { get; }
public IConnectionInfoProvider ConnectionInfo => connectionInfo;
public IRoomStateHelper RoomState { get; }
public IMessageLogHelper MessageLog { get; }
internal ArchipelagoSession(IArchipelagoSocketHelper socket, IReceivedItemsHelper items, ILocationCheckHelper locations, IPlayerHelper players, IRoomStateHelper roomState, ConnectionInfoHelper connectionInfoHelper, IDataStorageHelper dataStorage, IMessageLogHelper messageLog)
{
Socket = socket;
Items = items;
Locations = locations;
Players = players;
RoomState = roomState;
connectionInfo = connectionInfoHelper;
DataStorage = dataStorage;
MessageLog = messageLog;
socket.PacketReceived += Socket_PacketReceived;
}
private void Socket_PacketReceived(ArchipelagoPacketBase packet)
{
if (!(packet is ConnectedPacket) && !(packet is ConnectionRefusedPacket))
{
if (packet is RoomInfoPacket result)
{
roomInfoPacketTask.TrySetResult(result);
}
return;
}
if (packet is ConnectedPacket && RoomState.Version != null && RoomState.Version >= new Version(0, 3, 8))
{
LogUsedVersion();
}
loginResultTask.TrySetResult(LoginResult.FromPacket(packet));
}
private void LogUsedVersion()
{
try
{
string fileVersion = FileVersionInfo.GetVersionInfo(Assembly.GetExecutingAssembly().Location).FileVersion;
Socket.SendPacketAsync(new SetPacket
{
Key = ".NetUsedVersions",
DefaultValue = (JToken)(object)JObject.FromObject((object)new Dictionary<string, bool>()),
Operations = new OperationSpecification[1] { Operation.Update(new Dictionary<string, bool> {
{
ConnectionInfo.Game + ":" + fileVersion + ":NETSTANDARD2_0",
true
} }) }
});
}
catch
{
}
}
public Task<RoomInfoPacket> ConnectAsync()
{
roomInfoPacketTask = new TaskCompletionSource<RoomInfoPacket>();
Task.Factory.StartNew(delegate
{
try
{
Task task = Socket.ConnectAsync();
task.Wait(TimeSpan.FromSeconds(4.0));
if (!task.IsCompleted)
{
roomInfoPacketTask.TrySetCanceled();
}
}
catch (AggregateException)
{
roomInfoPacketTask.TrySetCanceled();
}
});
return roomInfoPacketTask.Task;
}
public Task<LoginResult> LoginAsync(string game, string name, ItemsHandlingFlags itemsHandlingFlags, Version version = null, string[] tags = null, string uuid = null, string password = null, bool requestSlotData = true)
{
loginResultTask = new TaskCompletionSource<LoginResult>();
if (!roomInfoPacketTask.Task.IsCompleted)
{
loginResultTask.TrySetResult(new LoginFailure("You are not connected, run ConnectAsync() first"));
return loginResultTask.Task;
}
connectionInfo.SetConnectionParameters(game, tags, itemsHandlingFlags, uuid);
try
{
Socket.SendPacket(BuildConnectPacket(name, password, version, requestSlotData));
}
catch (ArchipelagoSocketClosedException)
{
loginResultTask.TrySetResult(new LoginFailure("You are not connected, run ConnectAsync() first"));
return loginResultTask.Task;
}
SetResultAfterTimeout(loginResultTask, 4, new LoginFailure("Connection timed out."));
return loginResultTask.Task;
}
private static void SetResultAfterTimeout<T>(TaskCompletionSource<T> task, int timeoutInSeconds, T result)
{
new CancellationTokenSource(TimeSpan.FromSeconds(timeoutInSeconds)).Token.Register(delegate
{
task.TrySetResult(result);
});
}
public LoginResult TryConnectAndLogin(string game, string name, ItemsHandlingFlags itemsHandlingFlags, Version version = null, string[] tags = null, string uuid = null, string password = null, bool requestSlotData = true)
{
Task<RoomInfoPacket> task = ConnectAsync();
try
{
task.Wait(TimeSpan.FromSeconds(4.0));
}
catch (AggregateException ex)
{
if (ex.GetBaseException() is OperationCanceledException)
{
return new LoginFailure("Connection timed out.");
}
return new LoginFailure(ex.GetBaseException().Message);
}
if (!task.IsCompleted)
{
return new LoginFailure("Connection timed out.");
}
return LoginAsync(game, name, itemsHandlingFlags, version, tags, uuid, password, requestSlotData).Result;
}
private ConnectPacket BuildConnectPacket(string name, string password, Version version, bool requestSlotData)
{
return new ConnectPacket
{
Game = ConnectionInfo.Game,
Name = name,
Password = password,
Tags = ConnectionInfo.Tags,
Uuid = ConnectionInfo.Uuid,
Version = ((version != null) ? new NetworkVersion(version) : new NetworkVersion(0, 6, 0)),
ItemsHandling = ConnectionInfo.ItemsHandlingFlags,
RequestSlotData = requestSlotData
};
}
public void Say(string message)
{
Socket.SendPacket(new SayPacket
{
Text = message
});
}
public void SetClientState(ArchipelagoClientState state)
{
Socket.SendPacket(new StatusUpdatePacket
{
Status = state
});
}
public void SetGoalAchieved()
{
SetClientState(ArchipelagoClientState.ClientGoal);
}
}
public interface IArchipelagoSessionActions
{
void Say(string message);
void SetClientState(ArchipelagoClientState state);
void SetGoalAchieved();
}
public static class ArchipelagoSessionFactory
{
public static ArchipelagoSession CreateSession(Uri uri)
{
ArchipelagoSocketHelper socket = new ArchipelagoSocketHelper(uri);
DataPackageCache cache = new DataPackageCache(socket);
ConnectionInfoHelper connectionInfoHelper = new ConnectionInfoHelper(socket);
PlayerHelper playerHelper = new PlayerHelper(socket, connectionInfoHelper);
ItemInfoResolver itemInfoResolver = new ItemInfoResolver(cache, connectionInfoHelper);
LocationCheckHelper locationCheckHelper = new LocationCheckHelper(socket, itemInfoResolver, connectionInfoHelper, playerHelper);
ReceivedItemsHelper items = new ReceivedItemsHelper(socket, locationCheckHelper, itemInfoResolver, connectionInfoHelper, playerHelper);
RoomStateHelper roomState = new RoomStateHelper(socket, locationCheckHelper);
DataStorageHelper dataStorage = new DataStorageHelper(socket, connectionInfoHelper);
MessageLogHelper messageLog = new MessageLogHelper(socket, itemInfoResolver, playerHelper, connectionInfoHelper);
return new ArchipelagoSession(socket, items, locationCheckHelper, playerHelper, roomState, connectionInfoHelper, dataStorage, messageLog);
}
public static ArchipelagoSession CreateSession(string hostname, int port = 38281)
{
return CreateSession(ParseUri(hostname, port));
}
internal static Uri ParseUri(string hostname, int port)
{
string text = hostname;
if (!text.StartsWith("ws://") && !text.StartsWith("wss://"))
{
text = "unspecified://" + text;
}
if (!text.Substring(text.IndexOf("://", StringComparison.Ordinal) + 3).Contains(":"))
{
text += $":{port}";
}
if (text.EndsWith(":"))
{
text += port;
}
return new Uri(text);
}
}
public abstract class LoginResult
{
public abstract bool Successful { get; }
public static LoginResult FromPacket(ArchipelagoPacketBase packet)
{
if (!(packet is ConnectedPacket connectedPacket))
{
if (packet is ConnectionRefusedPacket connectionRefusedPacket)
{
return new LoginFailure(connectionRefusedPacket);
}
throw new ArgumentOutOfRangeException("packet", "packet is not a connection result packet");
}
return new LoginSuccessful(connectedPacket);
}
}
public class LoginSuccessful : LoginResult
{
public override bool Successful => true;
public int Team { get; }
public int Slot { get; }
public Dictionary<string, object> SlotData { get; }
public LoginSuccessful(ConnectedPacket connectedPacket)
{
Team = connectedPacket.Team;
Slot = connectedPacket.Slot;
SlotData = connectedPacket.SlotData;
}
}
public class LoginFailure : LoginResult
{
public override bool Successful => false;
public ConnectionRefusedError[] ErrorCodes { get; }
public string[] Errors { get; }
public LoginFailure(ConnectionRefusedPacket connectionRefusedPacket)
{
if (connectionRefusedPacket.Errors != null)
{
ErrorCodes = connectionRefusedPacket.Errors.ToArray();
Errors = ErrorCodes.Select(GetErrorMessage).ToArray();
}
else
{
ErrorCodes = new ConnectionRefusedError[0];
Errors = new string[0];
}
}
public LoginFailure(string message)
{
ErrorCodes = new ConnectionRefusedError[0];
Errors = new string[1] { message };
}
private static string GetErrorMessage(ConnectionRefusedError errorCode)
{
return errorCode switch
{
ConnectionRefusedError.InvalidSlot => "The slot name did not match any slot on the server.",
ConnectionRefusedError.InvalidGame => "The slot is set to a different game on the server.",
ConnectionRefusedError.SlotAlreadyTaken => "The slot already has a connection with a different uuid established.",
ConnectionRefusedError.IncompatibleVersion => "The client and server version mismatch.",
ConnectionRefusedError.InvalidPassword => "The password is invalid.",
ConnectionRefusedError.InvalidItemsHandling => "The item handling flags provided are invalid.",
_ => $"Unknown error: {errorCode}.",
};
}
}
internal class TwoWayLookup<TA, TB> : IEnumerable<KeyValuePair<TB, TA>>, IEnumerable
{
private readonly Dictionary<TA, TB> aToB = new Dictionary<TA, TB>();
private readonly Dictionary<TB, TA> bToA = new Dictionary<TB, TA>();
public TA this[TB b] => bToA[b];
public TB this[TA a] => aToB[a];
public void Add(TA a, TB b)
{
aToB[a] = b;
bToA[b] = a;
}
public void Add(TB b, TA a)
{
Add(a, b);
}
public bool TryGetValue(TA a, out TB b)
{
return aToB.TryGetValue(a, out b);
}
public bool TryGetValue(TB b, out TA a)
{
return bToA.TryGetValue(b, out a);
}
public IEnumerator<KeyValuePair<TB, TA>> GetEnumerator()
{
return bToA.GetEnumerator();
}
IEnumerator IEnumerable.GetEnumerator()
{
return GetEnumerator();
}
}
}
namespace Archipelago.MultiClient.Net.Packets
{
public class BouncedPacket : BouncePacket
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.Bounced;
}
public class BouncePacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.Bounce;
[JsonProperty("games")]
public List<string> Games { get; set; } = new List<string>();
[JsonProperty("slots")]
public List<int> Slots { get; set; } = new List<int>();
[JsonProperty("tags")]
public List<string> Tags { get; set; } = new List<string>();
[JsonProperty("data")]
public Dictionary<string, JToken> Data { get; set; }
}
public class ConnectedPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.Connected;
[JsonProperty("team")]
public int Team { get; set; }
[JsonProperty("slot")]
public int Slot { get; set; }
[JsonProperty("players")]
public NetworkPlayer[] Players { get; set; }
[JsonProperty("missing_locations")]
public long[] MissingChecks { get; set; }
[JsonProperty("checked_locations")]
public long[] LocationsChecked { get; set; }
[JsonProperty("slot_data")]
public Dictionary<string, object> SlotData { get; set; }
[JsonProperty("slot_info")]
public Dictionary<int, NetworkSlot> SlotInfo { get; set; }
[JsonProperty("hint_points")]
public int? HintPoints { get; set; }
}
public class ConnectionRefusedPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.ConnectionRefused;
[JsonProperty("errors", ItemConverterType = typeof(AttemptingStringEnumConverter))]
public ConnectionRefusedError[] Errors { get; set; }
}
public class ConnectPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.Connect;
[JsonProperty("password")]
public string Password { get; set; }
[JsonProperty("game")]
public string Game { get; set; }
[JsonProperty("name")]
public string Name { get; set; }
[JsonProperty("uuid")]
public string Uuid { get; set; }
[JsonProperty("version")]
public NetworkVersion Version { get; set; }
[JsonProperty("tags")]
public string[] Tags { get; set; }
[JsonProperty("items_handling")]
public ItemsHandlingFlags ItemsHandling { get; set; }
[JsonProperty("slot_data")]
public bool RequestSlotData { get; set; }
}
public class ConnectUpdatePacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.ConnectUpdate;
[JsonProperty("tags")]
public string[] Tags { get; set; }
[JsonProperty("items_handling")]
public ItemsHandlingFlags? ItemsHandling { get; set; }
}
public class DataPackagePacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.DataPackage;
[JsonProperty("data")]
public Archipelago.MultiClient.Net.Models.DataPackage DataPackage { get; set; }
}
public class GetDataPackagePacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.GetDataPackage;
[JsonProperty("games")]
public string[] Games { get; set; }
}
public class GetPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.Get;
[JsonProperty("keys")]
public string[] Keys { get; set; }
}
public class InvalidPacketPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.InvalidPacket;
[JsonProperty("type")]
public InvalidPacketErrorType ErrorType { get; set; }
[JsonProperty("text")]
public string ErrorText { get; set; }
[JsonProperty("original_cmd")]
public ArchipelagoPacketType OriginalCmd { get; set; }
}
public class LocationChecksPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.LocationChecks;
[JsonProperty("locations")]
public long[] Locations { get; set; }
}
public class LocationInfoPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.LocationInfo;
[JsonProperty("locations")]
public NetworkItem[] Locations { get; set; }
}
public class LocationScoutsPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.LocationScouts;
[JsonProperty("locations")]
public long[] Locations { get; set; }
[JsonProperty("create_as_hint")]
public int CreateAsHint { get; set; }
}
public class PrintJsonPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.PrintJSON;
[JsonProperty("data")]
public JsonMessagePart[] Data { get; set; }
[JsonProperty("type")]
[JsonConverter(typeof(StringEnumConverter))]
public JsonMessageType? MessageType { get; set; }
}
public class ItemPrintJsonPacket : PrintJsonPacket
{
[JsonProperty("receiving")]
public int ReceivingPlayer { get; set; }
[JsonProperty("item")]
public NetworkItem Item { get; set; }
}
public class ItemCheatPrintJsonPacket : PrintJsonPacket
{
[JsonProperty("receiving")]
public int ReceivingPlayer { get; set; }
[JsonProperty("item")]
public NetworkItem Item { get; set; }
[JsonProperty("team")]
public int Team { get; set; }
}
public class HintPrintJsonPacket : PrintJsonPacket
{
[JsonProperty("receiving")]
public int ReceivingPlayer { get; set; }
[JsonProperty("item")]
public NetworkItem Item { get; set; }
[JsonProperty("found")]
public bool? Found { get; set; }
}
public class JoinPrintJsonPacket : PrintJsonPacket
{
[JsonProperty("team")]
public int Team { get; set; }
[JsonProperty("slot")]
public int Slot { get; set; }
[JsonProperty("tags")]
public string[] Tags { get; set; }
}
public class LeavePrintJsonPacket : PrintJsonPacket
{
[JsonProperty("team")]
public int Team { get; set; }
[JsonProperty("slot")]
public int Slot { get; set; }
}
public class ChatPrintJsonPacket : PrintJsonPacket
{
[JsonProperty("team")]
public int Team { get; set; }
[JsonProperty("slot")]
public int Slot { get; set; }
[JsonProperty("message")]
public string Message { get; set; }
}
public class ServerChatPrintJsonPacket : PrintJsonPacket
{
[JsonProperty("message")]
public string Message { get; set; }
}
public class TutorialPrintJsonPacket : PrintJsonPacket
{
}
public class TagsChangedPrintJsonPacket : PrintJsonPacket
{
[JsonProperty("team")]
public int Team { get; set; }
[JsonProperty("slot")]
public int Slot { get; set; }
[JsonProperty("tags")]
public string[] Tags { get; set; }
}
public class CommandResultPrintJsonPacket : PrintJsonPacket
{
}
public class AdminCommandResultPrintJsonPacket : PrintJsonPacket
{
}
public class GoalPrintJsonPacket : PrintJsonPacket
{
[JsonProperty("team")]
public int Team { get; set; }
[JsonProperty("slot")]
public int Slot { get; set; }
}
public class ReleasePrintJsonPacket : PrintJsonPacket
{
[JsonProperty("team")]
public int Team { get; set; }
[JsonProperty("slot")]
public int Slot { get; set; }
}
public class CollectPrintJsonPacket : PrintJsonPacket
{
[JsonProperty("team")]
public int Team { get; set; }
[JsonProperty("slot")]
public int Slot { get; set; }
}
public class CountdownPrintJsonPacket : PrintJsonPacket
{
[JsonProperty("countdown")]
public int RemainingSeconds { get; set; }
}
public class ReceivedItemsPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.ReceivedItems;
[JsonProperty("index")]
public int Index { get; set; }
[JsonProperty("items")]
public NetworkItem[] Items { get; set; }
}
public class RetrievedPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.Retrieved;
[JsonProperty("keys")]
public Dictionary<string, JToken> Data { get; set; }
}
public class RoomInfoPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.RoomInfo;
[JsonProperty("version")]
public NetworkVersion Version { get; set; }
[JsonProperty("generator_version")]
public NetworkVersion GeneratorVersion { get; set; }
[JsonProperty("tags")]
public string[] Tags { get; set; }
[JsonProperty("password")]
public bool Password { get; set; }
[JsonProperty("permissions")]
public Dictionary<string, Permissions> Permissions { get; set; }
[JsonProperty("hint_cost")]
public int HintCostPercentage { get; set; }
[JsonProperty("location_check_points")]
public int LocationCheckPoints { get; set; }
[JsonProperty("players")]
public NetworkPlayer[] Players { get; set; }
[JsonProperty("games")]
public string[] Games { get; set; }
[JsonProperty("datapackage_checksums")]
public Dictionary<string, string> DataPackageChecksums { get; set; }
[JsonProperty("seed_name")]
public string SeedName { get; set; }
[JsonProperty("time")]
public double Timestamp { get; set; }
}
public class RoomUpdatePacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.RoomUpdate;
[JsonProperty("tags")]
public string[] Tags { get; set; }
[JsonProperty("password")]
public bool? Password { get; set; }
[JsonProperty("permissions")]
public Dictionary<string, Permissions> Permissions { get; set; } = new Dictionary<string, Permissions>();
[JsonProperty("hint_cost")]
public int? HintCostPercentage { get; set; }
[JsonProperty("location_check_points")]
public int? LocationCheckPoints { get; set; }
[JsonProperty("players")]
public NetworkPlayer[] Players { get; set; }
[JsonProperty("hint_points")]
public int? HintPoints { get; set; }
[JsonProperty("checked_locations")]
public long[] CheckedLocations { get; set; }
}
public class SayPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.Say;
[JsonProperty("text")]
public string Text { get; set; }
}
public class SetNotifyPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.SetNotify;
[JsonProperty("keys")]
public string[] Keys { get; set; }
}
public class SetPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.Set;
[JsonProperty("key")]
public string Key { get; set; }
[JsonProperty("default")]
public JToken DefaultValue { get; set; }
[JsonProperty("operations")]
public OperationSpecification[] Operations { get; set; }
[JsonProperty("want_reply")]
public bool WantReply { get; set; }
[JsonExtensionData]
public Dictionary<string, JToken> AdditionalArguments { get; set; }
[OnDeserialized]
internal void OnDeserializedMethod(StreamingContext context)
{
AdditionalArguments?.Remove("cmd");
}
}
public class SetReplyPacket : SetPacket
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.SetReply;
[JsonProperty("value")]
public JToken Value { get; set; }
[JsonProperty("original_value")]
public JToken OriginalValue { get; set; }
}
public class StatusUpdatePacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.StatusUpdate;
[JsonProperty("status")]
public ArchipelagoClientState Status { get; set; }
}
public class SyncPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.Sync;
}
internal class UnknownPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.Unknown;
}
public class UpdateHintPacket : ArchipelagoPacketBase
{
public override ArchipelagoPacketType PacketType => ArchipelagoPacketType.UpdateHint;
[JsonProperty("player")]
public int Player { get; set; }
[JsonProperty("location")]
public long Location { get; set; }
[JsonProperty("status")]
public HintStatus Status { get; set; }
}
}
namespace Archipelago.MultiClient.Net.Models
{
public struct Color : IEquatable<Color>
{
public static Color Red = new Color(byte.MaxValue, 0, 0);
public static Color Green = new Color(0, 128, 0);
public static Color Yellow = new Color(byte.MaxValue, byte.MaxValue, 0);
public static Color Blue = new Color(0, 0, byte.MaxValue);
public static Color Magenta = new Color(byte.MaxValue, 0, byte.MaxValue);
public static Color Cyan = new Color(0, byte.MaxValue, byte.MaxValue);
public static Color Black = new Color(0, 0, 0);
public static Color White = new Color(byte.MaxValue, byte.MaxValue, byte.MaxValue);
public static Color SlateBlue = new Color(106, 90, 205);
public static Color Salmon = new Color(250, 128, 114);
public static Color Plum = new Color(221, 160, 221);
public byte R { get; set; }
public byte G { get; set; }
public byte B { get; set; }
public Color(byte r, byte g, byte b)
{
R = r;
G = g;
B = b;
}
public override bool Equals(object obj)
{
if (obj is Color color && R == color.R && G == color.G)
{
return B == color.B;
}
return false;
}
public bool Equals(Color other)
{
if (R == other.R && G == other.G)
{
return B == other.B;
}
return false;
}
public override int GetHashCode()
{
return ((-1520100960 * -1521134295 + R.GetHashCode()) * -1521134295 + G.GetHashCode()) * -1521134295 + B.GetHashCode();
}
public static bool operator ==(Color left, Color right)
{
return left.Equals(right);
}
public static bool operator !=(Color left, Color right)
{
return !(left == right);
}
}
public class DataPackage
{
[JsonProperty("games")]
public Dictionary<string, GameData> Games { get; set; } = new Dictionary<string, GameData>();
}
public class DataStorageElement
{
internal DataStorageElementContext Context;
internal List<OperationSpecification> Operations = new List<OperationSpecification>(0);
internal DataStorageHelper.DataStorageUpdatedHandler Callbacks;
internal Dictionary<string, JToken> AdditionalArguments = new Dictionary<string, JToken>(0);
private JToken cachedValue;
public event DataStorageHelper.DataStorageUpdatedHandler OnValueChanged
{
add
{
Context.AddHandler(Context.Key, value);
}
remove
{
Context.RemoveHandler(Context.Key, value);
}
}
internal DataStorageElement(DataStorageElementContext context)
{
Context = context;
}
internal DataStorageElement(OperationType operationType, JToken value)
{
Operations = new List<OperationSpecification>(1)
{
new OperationSpecification
{
OperationType = operationType,
Value = value
}
};
}
internal DataStorageElement(DataStorageElement source, OperationType operationType, JToken value)
: this(source.Context)
{
Operations = source.Operations.ToList();
Callbacks = source.Callbacks;
AdditionalArguments = source.AdditionalArguments;
Operations.Add(new OperationSpecification
{
OperationType = operationType,
Value = value
});
}
internal DataStorageElement(DataStorageElement source, Callback callback)
: this(source.Context)
{
Operations = source.Operations.ToList();
Callbacks = source.Callbacks;
AdditionalArguments = source.AdditionalArguments;
Callbacks = (DataStorageHelper.DataStorageUpdatedHandler)Delegate.Combine(Callbacks, callback.Method);
}
internal DataStorageElement(DataStorageElement source, AdditionalArgument additionalArgument)
: this(source.Context)
{
Operations = source.Operations.ToList();
Callbacks = source.Callbacks;
AdditionalArguments = source.AdditionalArguments;
AdditionalArguments[additionalArgument.Key] = additionalArgument.Value;
}
public static DataStorageElement operator ++(DataStorageElement a)
{
return new DataStorageElement(a, OperationType.Add, JToken.op_Implicit(1));
}
public static DataStorageElement operator --(DataStorageElement a)
{
return new DataStorageElement(a, OperationType.Add, JToken.op_Implicit(-1));
}
public static DataStorageElement operator +(DataStorageElement a, int b)
{
return new DataStorageElement(a, OperationType.Add, JToken.op_Implicit(b));
}
public static DataStorageElement operator +(DataStorageElement a, long b)
{
return new DataStorageElement(a, OperationType.Add, JToken.op_Implicit(b));
}
public static DataStorageElement operator +(DataStorageElement a, float b)
{
return new DataStorageElement(a, OperationType.Add, JToken.op_Implicit(b));
}
public static DataStorageElement operator +(DataStorageElement a, double b)
{
return new DataStorageElement(a, OperationType.Add, JToken.op_Implicit(b));
}
public static DataStorageElement operator +(DataStorageElement a, decimal b)
{
return new DataStorageElement(a, OperationType.Add, JToken.op_Implicit(b));
}
public static DataStorageElement operator +(DataStorageElement a, string b)
{
return new DataStorageElement(a, OperationType.Add, JToken.op_Implicit(b));
}
public static DataStorageElement operator +(DataStorageElement a, JToken b)
{
return new DataStorageElement(a, OperationType.Add, b);
}
public static DataStorageElement operator +(DataStorageElement a, IEnumerable b)
{
return new DataStorageElement(a, OperationType.Add, (JToken)(object)JArray.FromObject((object)b));
}
public static DataStorageElement operator +(DataStorageElement a, OperationSpecification s)
{
return new DataStorageElement(a, s.OperationType, s.Value);
}
public static DataStorageElement operator +(DataStorageElement a, Callback c)
{
return new DataStorageElement(a, c);
}
public static DataStorageElement operator +(DataStorageElement a, AdditionalArgument arg)
{
return new DataStorageElement(a, arg);
}
public static DataStorageElement operator *(DataStorageElement a, int b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.op_Implicit(b));
}
public static DataStorageElement operator *(DataStorageElement a, long b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.op_Implicit(b));
}
public static DataStorageElement operator *(DataStorageElement a, float b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.op_Implicit(b));
}
public static DataStorageElement operator *(DataStorageElement a, double b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.op_Implicit(b));
}
public static DataStorageElement operator *(DataStorageElement a, decimal b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.op_Implicit(b));
}
public static DataStorageElement operator %(DataStorageElement a, int b)
{
return new DataStorageElement(a, OperationType.Mod, JToken.op_Implicit(b));
}
public static DataStorageElement operator %(DataStorageElement a, long b)
{
return new DataStorageElement(a, OperationType.Mod, JToken.op_Implicit(b));
}
public static DataStorageElement operator %(DataStorageElement a, float b)
{
return new DataStorageElement(a, OperationType.Mod, JToken.op_Implicit(b));
}
public static DataStorageElement operator %(DataStorageElement a, double b)
{
return new DataStorageElement(a, OperationType.Mod, JToken.op_Implicit(b));
}
public static DataStorageElement operator %(DataStorageElement a, decimal b)
{
return new DataStorageElement(a, OperationType.Mod, JToken.op_Implicit(b));
}
public static DataStorageElement operator ^(DataStorageElement a, int b)
{
return new DataStorageElement(a, OperationType.Pow, JToken.op_Implicit(b));
}
public static DataStorageElement operator ^(DataStorageElement a, long b)
{
return new DataStorageElement(a, OperationType.Pow, JToken.op_Implicit(b));
}
public static DataStorageElement operator ^(DataStorageElement a, float b)
{
return new DataStorageElement(a, OperationType.Pow, JToken.op_Implicit(b));
}
public static DataStorageElement operator ^(DataStorageElement a, double b)
{
return new DataStorageElement(a, OperationType.Pow, JToken.op_Implicit(b));
}
public static DataStorageElement operator ^(DataStorageElement a, decimal b)
{
return new DataStorageElement(a, OperationType.Pow, JToken.op_Implicit(b));
}
public static DataStorageElement operator -(DataStorageElement a, int b)
{
return new DataStorageElement(a, OperationType.Add, JToken.FromObject((object)(-b)));
}
public static DataStorageElement operator -(DataStorageElement a, long b)
{
return new DataStorageElement(a, OperationType.Add, JToken.FromObject((object)(-b)));
}
public static DataStorageElement operator -(DataStorageElement a, float b)
{
return new DataStorageElement(a, OperationType.Add, JToken.FromObject((object)(0f - b)));
}
public static DataStorageElement operator -(DataStorageElement a, double b)
{
return new DataStorageElement(a, OperationType.Add, JToken.FromObject((object)(0.0 - b)));
}
public static DataStorageElement operator -(DataStorageElement a, decimal b)
{
return new DataStorageElement(a, OperationType.Add, JToken.FromObject((object)(-b)));
}
public static DataStorageElement operator /(DataStorageElement a, int b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.FromObject((object)(1m / (decimal)b)));
}
public static DataStorageElement operator /(DataStorageElement a, long b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.FromObject((object)(1m / (decimal)b)));
}
public static DataStorageElement operator /(DataStorageElement a, float b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.FromObject((object)(1.0 / (double)b)));
}
public static DataStorageElement operator /(DataStorageElement a, double b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.FromObject((object)(1.0 / b)));
}
public static DataStorageElement operator /(DataStorageElement a, decimal b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.FromObject((object)(1m / b)));
}
public static implicit operator DataStorageElement(bool b)
{
return new DataStorageElement(OperationType.Replace, JToken.op_Implicit(b));
}
public static implicit operator DataStorageElement(int i)
{
return new DataStorageElement(OperationType.Replace, JToken.op_Implicit(i));
}
public static implicit operator DataStorageElement(long l)
{
return new DataStorageElement(OperationType.Replace, JToken.op_Implicit(l));
}
public static implicit operator DataStorageElement(decimal m)
{
return new DataStorageElement(OperationType.Replace, JToken.op_Implicit(m));
}
public static implicit operator DataStorageElement(double d)
{
return new DataStorageElement(OperationType.Replace, JToken.op_Implicit(d));
}
public static implicit operator DataStorageElement(float f)
{
return new DataStorageElement(OperationType.Replace, JToken.op_Implicit(f));
}
public static implicit operator DataStorageElement(string s)
{
if (s != null)
{
return new DataStorageElement(OperationType.Replace, JToken.op_Implicit(s));
}
return new DataStorageElement(OperationType.Replace, (JToken)(object)JValue.CreateNull());
}
public static implicit operator DataStorageElement(JToken o)
{
return new DataStorageElement(OperationType.Replace, o);
}
public static implicit operator DataStorageElement(Array a)
{
return new DataStorageElement(OperationType.Replace, (JToken)(object)JArray.FromObject((object)a));
}
public static implicit operator DataStorageElement(List<bool> l)
{
return new DataStorageElement(OperationType.Replace, (JToken)(object)JArray.FromObject((object)l));
}
public static implicit operator DataStorageElement(List<int> l)
{
return new DataStorageElement(OperationType.Replace, (JToken)(object)JArray.FromObject((object)l));
}
public static implicit operator DataStorageElement(List<long> l)
{
return new DataStorageElement(OperationType.Replace, (JToken)(object)JArray.FromObject((object)l));
}
public static implicit operator DataStorageElement(List<decimal> l)
{
return new DataStorageElement(OperationType.Replace, (JToken)(object)JArray.FromObject((object)l));
}
public static implicit operator DataStorageElement(List<double> l)
{
return new DataStorageElement(OperationType.Replace, (JToken)(object)JArray.FromObject((object)l));
}
public static implicit operator DataStorageElement(List<float> l)
{
return new DataStorageElement(OperationType.Replace, (JToken)(object)JArray.FromObject((object)l));
}
public static implicit operator DataStorageElement(List<string> l)
{
return new DataStorageElement(OperationType.Replace, (JToken)(object)JArray.FromObject((object)l));
}
public static implicit operator DataStorageElement(List<object> l)
{
return new DataStorageElement(OperationType.Replace, (JToken)(object)JArray.FromObject((object)l));
}
public static implicit operator bool(DataStorageElement e)
{
return RetrieveAndReturnBoolValue<bool>(e);
}
public static implicit operator bool?(DataStorageElement e)
{
return RetrieveAndReturnBoolValue<bool?>(e);
}
public static implicit operator int(DataStorageElement e)
{
return RetrieveAndReturnDecimalValue<int>(e);
}
public static implicit operator int?(DataStorageElement e)
{
return RetrieveAndReturnDecimalValue<int?>(e);
}
public static implicit operator long(DataStorageElement e)
{
return RetrieveAndReturnDecimalValue<long>(e);
}
public static implicit operator long?(DataStorageElement e)
{
return RetrieveAndReturnDecimalValue<long?>(e);
}
public static implicit operator float(DataStorageElement e)
{
return RetrieveAndReturnDecimalValue<float>(e);
}
public static implicit operator float?(DataStorageElement e)
{
return RetrieveAndReturnDecimalValue<float?>(e);
}
public static implicit operator double(DataStorageElement e)
{
return RetrieveAndReturnDecimalValue<double>(e);
}
public static implicit operator double?(DataStorageElement e)
{
return RetrieveAndReturnDecimalValue<double?>(e);
}
public static implicit operator decimal(DataStorageElement e)
{
return RetrieveAndReturnDecimalValue<decimal>(e);
}
public static implicit operator decimal?(DataStorageElement e)
{
return RetrieveAndReturnDecimalValue<decimal?>(e);
}
public static implicit operator string(DataStorageElement e)
{
return RetrieveAndReturnStringValue(e);
}
public static implicit operator bool[](DataStorageElement e)
{
return RetrieveAndReturnArrayValue<bool[]>(e);
}
public static implicit operator int[](DataStorageElement e)
{
return RetrieveAndReturnArrayValue<int[]>(e);
}
public static implicit operator long[](DataStorageElement e)
{
return RetrieveAndReturnArrayValue<long[]>(e);
}
public static implicit operator decimal[](DataStorageElement e)
{
return RetrieveAndReturnArrayValue<decimal[]>(e);
}
public static implicit operator double[](DataStorageElement e)
{
return RetrieveAndReturnArrayValue<double[]>(e);
}
public static implicit operator float[](DataStorageElement e)
{
return RetrieveAndReturnArrayValue<float[]>(e);
}
public static implicit operator string[](DataStorageElement e)
{
return RetrieveAndReturnArrayValue<string[]>(e);
}
public static implicit operator object[](DataStorageElement e)
{
return RetrieveAndReturnArrayValue<object[]>(e);
}
public static implicit operator List<bool>(DataStorageElement e)
{
return RetrieveAndReturnArrayValue<List<bool>>(e);
}
public static implicit operator List<int>(DataStorageElement e)
{
return RetrieveAndReturnArrayValue<List<int>>(e);
}
public static implicit operator List<long>(DataStorageElement e)
{
return RetrieveAndReturnArrayValue<List<long>>(e);
}
public static implicit operator List<decimal>(DataStorageElement e)
{
return RetrieveAndReturnArrayValue<List<decimal>>(e);
}
public static implicit operator List<double>(DataStorageElement e)
{
return RetrieveAndReturnArrayValue<List<double>>(e);
}
public static implicit operator List<float>(DataStorageElement e)
{
return RetrieveAndReturnArrayValue<List<float>>(e);
}
public static implicit operator List<string>(DataStorageElement e)
{
return RetrieveAndReturnArrayValue<List<string>>(e);
}
public static implicit operator List<object>(DataStorageElement e)
{
return RetrieveAndReturnArrayValue<List<object>>(e);
}
public static implicit operator Array(DataStorageElement e)
{
return RetrieveAndReturnArrayValue<Array>(e);
}
public static implicit operator JArray(DataStorageElement e)
{
return RetrieveAndReturnArrayValue<JArray>(e);
}
public static implicit operator JToken(DataStorageElement e)
{
return e.Context.GetData(e.Context.Key);
}
public static DataStorageElement operator +(DataStorageElement a, BigInteger b)
{
return new DataStorageElement(a, OperationType.Add, JToken.Parse(b.ToString()));
}
public static DataStorageElement operator *(DataStorageElement a, BigInteger b)
{
return new DataStorageElement(a, OperationType.Mul, JToken.Parse(b.ToString()));
}
public static DataStorageElement operator %(DataStorageElement a, BigInteger b)
{
return new DataStorageElement(a, OperationType.Mod, JToken.Parse(b.ToString()));
}
public static DataStorageElement operator ^(DataStorageElement a, BigInteger b)
{
return new DataStorageElement(a, OperationType.Pow, JToken.Parse(b.ToString()));
}
public static DataStorageElement operator -(DataStorageElement a, BigInteger b)
{
return new DataStorageElement(a, OperationType.Add, JToken.Parse((-b).ToString()));
}
public static DataStorageElement operator /(DataStorageElement a, BigInteger b)
{
throw new InvalidOperationException("DataStorage[Key] / BigInterger is not supported, due to loss of precision when using integer division");
}
public static implicit operator DataStorageElement(BigInteger bi)
{
return new DataStorageElement(OperationType.Replace, JToken.Parse(bi.ToString()));
}
public static implicit operator BigInteger(DataStorageElement e)
{
return RetrieveAndReturnBigIntegerValue<BigInteger>(e);
}
public static implicit operator BigInteger?(DataStorageElement e)
{
return RetrieveAndReturnBigIntegerValue<BigInteger?>(e);
}
private static T RetrieveAndReturnBigIntegerValue<T>(DataStorageElement e)
{
if (e.cachedValue != null)
{
if (!BigInteger.TryParse(((object)e.cachedValue).ToString(), out var result))
{
return default(T);
}
return (T)Convert.ChangeType(result, IsNullable<T>() ? Nullable.GetUnderlyingType(typeof(T)) : typeof(T));
}
BigInteger result2;
BigInteger? bigInteger = (BigInteger.TryParse(((object)e.Context.GetData(e.Context.Key)).ToString(), out result2) ? new BigInteger?(result2) : null);
if (!bigInteger.HasValue && !IsNullable<T>())
{
bigInteger = Activator.CreateInstance<BigInteger>();
}
foreach (OperationSpecification operation in e.Operations)
{
if (operation.OperationType == OperationType.Floor || operation.OperationType == OperationType.Ceil)
{
continue;
}
if (!BigInteger.TryParse(((object)operation.Value).ToString(), NumberStyles.AllowLeadingSign, null, out var result3))
{
throw new InvalidOperationException($"DataStorage[Key] cannot be converted to BigInterger as its value its not an integer number, value: {operation.Value}");
}
switch (operation.OperationType)
{
case OperationType.Replace:
bigInteger = result3;
break;
case OperationType.Add:
bigInteger += result3;
break;
case OperationType.Mul:
bigInteger *= result3;
break;
case OperationType.Mod:
bigInteger %= result3;
break;
case OperationType.Pow:
bigInteger = BigInteger.Pow(bigInteger.Value, (int)operation.Value);
break;
case OperationType.Max:
{
BigInteger value = result3;
BigInteger? bigInteger2 = bigInteger;
if (value > bigInteger2)
{
bigInteger = result3;
}
break;
}
case OperationType.Min:
{
BigInteger value = result3;
BigInteger? bigInteger2 = bigInteger;
if (value < bigInteger2)
{
bigInteger = result3;
}
break;
}
case OperationType.Xor:
bigInteger ^= result3;
break;
case OperationType.Or:
bigInteger |= result3;
break;
case OperationType.And:
bigInteger &= result3;
break;
case OperationType.LeftShift:
bigInteger <<= (int)operation.Value;
break;
case OperationType.RightShift:
bigInteger >>= (int)operation.Value;
break;
}
}
e.cachedValue = JToken.Parse(bigInteger.ToString());
if (!bigInteger.HasValue)
{
return default(T);
}
return (T)Convert.ChangeType(bigInteger.Value, IsNullable<T>() ? Nullable.GetUnderlyingType(typeof(T)) : typeof(T));
}
public void Initialize(JToken value)
{
Context.Initialize(Context.Key, value);
}
public void Initialize(IEnumerable value)
{
Context.Initialize(Context.Key, (JToken)(object)JArray.FromObject((object)value));
}
public Task<T> GetAsync<T>()
{
return GetAsync().ContinueWith((Task<JToken> r) => r.Result.ToObject<T>());
}
public Task<JToken> GetAsync()
{
return Context.GetAsync(Context.Key);
}
private static T RetrieveAndReturnArrayValue<T>(DataStorageElement e)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_003d: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Unknown result type (might be due to invalid IL or missing references)
//IL_0079: Invalid comparison between Unknown and I4
//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Invalid comparison between Unknown and I4
//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
if (e.cachedValue != null)
{
return ((JToken)(JArray)e.cachedValue).ToObject<T>();
}
JArray val = (JArray)(((object)e.Context.GetData(e.Context.Key).ToObject<JArray>()) ?? ((object)new JArray()));
foreach (OperationSpecification operation in e.Operations)
{
switch (operation.OperationType)
{
case OperationType.Add:
if ((int)operation.Value.Type != 2)
{
throw new InvalidOperationException($"Cannot perform operation {OperationType.Add} on Array value, with a non Array value: {operation.Value}");
}
((JContainer)val).Merge((object)operation.Value);
break;
case OperationType.Replace:
if ((int)operation.Value.Type != 2)
{
throw new InvalidOperationException($"Cannot replace Array value, with a non Array value: {operation.Value}");
}
val = (JArray)(((object)operation.Value.ToObject<JArray>()) ?? ((object)new JArray()));
break;
default:
throw new InvalidOperationException($"Cannot perform operation {operation.OperationType} on Array value");
}
}
e.cachedValue = (JToken)(object)val;
return ((JToken)val).ToObject<T>();
}
private static string RetrieveAndReturnStringValue(DataStorageElement e)
{
//IL_0031: Unknown result type (might be due to invalid IL or missing references)
//IL_0038: Invalid comparison between Unknown and I4
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00a4: Invalid comparison between Unknown and I4
if (e.cachedValue != null)
{
return (string)e.cachedValue;
}
JToken val = e.Context.GetData(e.Context.Key);
string text = (((int)val.Type == 10) ? null : ((object)val).ToString());
foreach (OperationSpecification operation in e.Operations)
{
switch (operation.OperationType)
{
case OperationType.Add:
text += (string)operation.Value;
break;
case OperationType.Mul:
if ((int)operation.Value.Type != 6)
{
throw new InvalidOperationException($"Cannot perform operation {OperationType.Mul} on string value, with a non interger value: {operation.Value}");
}
text = string.Concat(Enumerable.Repeat(text, (int)operation.Value));
break;
case OperationType.Replace:
text = (string)operation.Value;
break;
default:
throw new InvalidOperationException($"Cannot perform operation {operation.OperationType} on string value");
}
}
if (text == null)
{
e.cachedValue = (JToken)(object)JValue.CreateNull();
}
else
{
e.cachedValue = JToken.op_Implicit(text);
}
return (string)e.cachedValue;
}
private static T RetrieveAndReturnBoolValue<T>(DataStorageElement e)
{
if (e.cachedValue != null)
{
return e.cachedValue.ToObject<T>();
}
bool? flag = e.Context.GetData(e.Context.Key).ToObject<bool?>() ?? ((bool?)Activator.CreateInstance(typeof(T)));
foreach (OperationSpecification operation in e.Operations)
{
if (operation.OperationType == OperationType.Replace)
{
flag = (bool?)operation.Value;
continue;
}
throw new InvalidOperationException($"Cannot perform operation {operation.OperationType} on boolean value");
}
e.cachedValue = JToken.op_Implicit(flag);
if (!flag.HasValue)
{
return default(T);
}
return (T)Convert.ChangeType(flag.Value, IsNullable<T>() ? Nullable.GetUnderlyingType(typeof(T)) : typeof(T));
}
private static T RetrieveAndReturnDecimalValue<T>(DataStorageElement e)
{
if (e.cachedValue != null)
{
return e.cachedValue.ToObject<T>();
}
decimal? num = e.Context.GetData(e.Context.Key).ToObject<decimal?>();
if (!num.HasValue && !IsNullable<T>())
{
num = Activator.CreateInstance<decimal>();
}
foreach (OperationSpecification operation in e.Operations)
{
switch (operation.OperationType)
{
case OperationType.Replace:
num = (decimal)operation.Value;
break;
case OperationType.Add:
num += (decimal?)(decimal)operation.Value;
break;
case OperationType.Mul:
num *= (decimal?)(decimal)operation.Value;
break;
case OperationType.Mod:
num %= (decimal?)(decimal)operation.Value;
break;
case OperationType.Pow:
num = (decimal)Math.Pow((double)num.Value, (double)operation.Value);
break;
case OperationType.Max:
num = Math.Max(num.Value, (decimal)operation.Value);
break;
case OperationType.Min:
num = Math.Min(num.Value, (decimal)operation.Value);
break;
case OperationType.Xor:
num = (long)num.Value ^ (long)operation.Value;
break;
case OperationType.Or:
num = (long)num.Value | (long)operation.Value;
break;
case OperationType.And:
num = (long)num.Value & (long)operation.Value;
break;
case OperationType.LeftShift:
num = (long)num.Value << (int)operation.Value;
break;
case OperationType.RightShift:
num = (long)num.Value >> (int)operation.Value;
break;
case OperationType.Floor:
num = Math.Floor(num.Value);
break;
case OperationType.Ceil:
num = Math.Ceiling(num.Value);
break;
}
}
e.cachedValue = JToken.op_Implicit(num);
if (!num.HasValue)
{
return default(T);
}
return (T)Convert.ChangeType(num.Value, IsNullable<T>() ? Nullable.GetUnderlyingType(typeof(T)) : typeof(T));
}
private static bool IsNullable<T>()
{
if (typeof(T).IsGenericType)
{
return typeof(T).GetGenericTypeDefinition() == typeof(Nullable<>).GetGenericTypeDefinition();
}
return false;
}
public T To<T>()
{
if (Operations.Count != 0)
{
throw new InvalidOperationException("DataStorageElement.To<T>() cannot be used together with other operations on the DataStorageElement");
}
return Context.GetData(Context.Key).ToObject<T>();
}
public override string ToString()
{
return (Context?.ToString() ?? "(null)") + ", (" + ListOperations() + ")";
}
private string ListOperations()
{
if (Operations != null)
{
return string.Join(", ", Operations.Select((OperationSpecification o) => o.ToString()).ToArray());
}
return "none";
}
}
internal class DataStorageElementContext
{
internal string Key { get; set; }
internal Action<string, DataStorageHelper.DataStorageUpdatedHandler> AddHandler { get; set; }
internal Action<string, DataStorageHelper.DataStorageUpdatedHandler> RemoveHandler { get; set; }
internal Func<string, JToken> GetData { get; set; }
internal Action<string, JToken> Initialize { get; set; }
internal Func<string, Task<JToken>> GetAsync { get; set; }
public override string ToString()
{
return "Key: " + Key;
}
}
public class GameData
{
[JsonProperty("location_name_to_id")]
public Dictionary<string, long> LocationLookup { get; set; } = new Dictionary<string, long>();
[JsonProperty("item_name_to_id")]
public Dictionary<string, long> ItemLookup { get; set; } = new Dictionary<string, long>();
[Obsolete("use Checksum instead")]
[JsonProperty("version")]
public int Version { get; set; }
[JsonProperty("checksum")]
public string Checksum { get; set; }
}
public class Hint
{
[JsonProperty("receiving_player")]
public int ReceivingPlayer { get; set; }
[JsonProperty("finding_player")]
public int FindingPlayer { get; set; }
[JsonProperty("item")]
public long ItemId { get; set; }
[JsonProperty("location")]
public long LocationId { get; set; }
[JsonProperty("item_flags")]
public ItemFlags ItemFlags { get; set; }
[JsonProperty("found")]
public bool Found { get; set; }
[JsonProperty("entrance")]
public string Entrance { get; set; }
[JsonProperty("status")]
public HintStatus Status { get; set; }
}
public class ItemInfo
{
private readonly IItemInfoResolver itemInfoResolver;
public long ItemId { get; }
public long LocationId { get; }
public PlayerInfo Player { get; }
public ItemFlags Flags { get; }
public string ItemName => itemInfoResolver.GetItemName(ItemId, ItemGame);
public string ItemDisplayName => ItemName ?? $"Item: {ItemId}";
public string LocationName => itemInfoResolver.GetLocationName(LocationId, LocationGame);
public string LocationDisplayName => LocationName ?? $"Location: {LocationId}";
public string ItemGame { get; }
public string LocationGame { get; }
public ItemInfo(NetworkItem item, string receiverGame, string senderGame, IItemInfoResolver itemInfoResolver, PlayerInfo player)
{
this.itemInfoResolver = itemInfoResolver;
ItemGame = receiverGame;
LocationGame = senderGame;
ItemId = item.Item;
LocationId = item.Location;
Flags = item.Flags;
Player = player;
}
public SerializableItemInfo ToSerializable()
{
return new SerializableItemInfo
{
IsScout = (GetType() == typeof(ScoutedItemInfo)),
ItemId = ItemId,
LocationId = LocationId,
PlayerSlot = Player,
Player = Player,
Flags = Flags,
ItemGame = ItemGame,
ItemName = ItemName,
LocationGame = LocationGame,
LocationName = LocationName
};
}
}
public class ScoutedItemInfo : ItemInfo
{
public new PlayerInfo Player => base.Player;
public bool IsReceiverRelatedToActivePlayer { get; }
public ScoutedItemInfo(NetworkItem item, string receiverGame, string senderGame, IItemInfoResolver itemInfoResolver, IPlayerHelper players, PlayerInfo player)
: base(item, receiverGame, senderGame, itemInfoResolver, player)
{
IsReceiverRelatedToActivePlayer = (players.ActivePlayer ?? new PlayerInfo()).IsRelatedTo(player);
}
}
public class JsonMessagePart
{
[JsonProperty("type")]
[JsonConverter(typeof(AttemptingStringEnumConverter), new object[] { typeof(SnakeCaseNamingStrategy) })]
public JsonMessagePartType? Type { get; set; }
[JsonProperty("color")]
[JsonConverter(typeof(AttemptingStringEnumConverter), new object[] { typeof(SnakeCaseNamingStrategy) })]
public JsonMessagePartColor? Color { get; set; }
[JsonProperty("text")]
public string Text { get; set; }
[JsonProperty("player")]
public int? Player { get; set; }
[JsonProperty("flags")]
public ItemFlags? Flags { get; set; }
[JsonProperty("hint_status")]
public HintStatus? HintStatus { get; set; }
}
public struct NetworkItem
{
[JsonProperty("item")]
public long Item { get; set; }
[JsonProperty("location")]
public long Location { get; set; }
[JsonProperty("player")]
public int Player { get; set; }
[JsonProperty("flags")]
public ItemFlags Flags { get; set; }
}
public struct NetworkPlayer
{
[JsonProperty("team")]
public int Team { get; set; }
[JsonProperty("slot")]
public int Slot { get; set; }
[JsonProperty("alias")]
public string Alias { get; set; }
[JsonProperty("name")]
public string Name { get; set; }
}
public struct NetworkSlot
{
[JsonProperty("name")]
public string Name { get; set; }
[JsonProperty("game")]
public string Game { get; set; }
[JsonProperty("type")]
public SlotType Type { get; set; }
[JsonProperty("group_members")]
public int[] GroupMembers { get; set; }
}
public class NetworkVersion
{
[JsonProperty("major")]
public int Major { get; set; }
[JsonProperty("minor")]
public int Minor { get; set; }
[JsonProperty("build")]
public int Build { get; set; }
[JsonProperty("class")]
public string Class => "Version";
public NetworkVersion()
{
}
public NetworkVersion(int major, int minor, int build)
{
Major = major;
Minor = minor;
Build = build;
}
public NetworkVersion(Version version)
{
Major = version.Major;
Minor = version.Minor;
Build = version.Build;
}
public Version ToVersion()
{
return new Version(Major, Minor, Build);
}
}
public class OperationSpecification
{
[JsonProperty("operation")]
[JsonConverter(typeof(AttemptingStringEnumConverter), new object[] { typeof(SnakeCaseNamingStrategy) })]
public OperationType OperationType;
[JsonProperty("value")]
public JToken Value { get; set; }
public override string ToString()
{
return $"{OperationType}: {Value}";
}
}
public static class Operation
{
public static OperationSpecification Min(int i)
{
return new OperationSpecification
{
OperationType = OperationType.Min,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Min(long i)
{
return new OperationSpecification
{
OperationType = OperationType.Min,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Min(float i)
{
return new OperationSpecification
{
OperationType = OperationType.Min,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Min(double i)
{
return new OperationSpecification
{
OperationType = OperationType.Min,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Min(decimal i)
{
return new OperationSpecification
{
OperationType = OperationType.Min,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Min(JToken i)
{
return new OperationSpecification
{
OperationType = OperationType.Min,
Value = i
};
}
public static OperationSpecification Min(BigInteger i)
{
return new OperationSpecification
{
OperationType = OperationType.Min,
Value = JToken.Parse(i.ToString())
};
}
public static OperationSpecification Max(int i)
{
return new OperationSpecification
{
OperationType = OperationType.Max,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Max(long i)
{
return new OperationSpecification
{
OperationType = OperationType.Max,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Max(float i)
{
return new OperationSpecification
{
OperationType = OperationType.Max,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Max(double i)
{
return new OperationSpecification
{
OperationType = OperationType.Max,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Max(decimal i)
{
return new OperationSpecification
{
OperationType = OperationType.Max,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Max(JToken i)
{
return new OperationSpecification
{
OperationType = OperationType.Max,
Value = i
};
}
public static OperationSpecification Max(BigInteger i)
{
return new OperationSpecification
{
OperationType = OperationType.Max,
Value = JToken.Parse(i.ToString())
};
}
public static OperationSpecification Remove(JToken value)
{
return new OperationSpecification
{
OperationType = OperationType.Remove,
Value = value
};
}
public static OperationSpecification Pop(int value)
{
return new OperationSpecification
{
OperationType = OperationType.Pop,
Value = JToken.op_Implicit(value)
};
}
public static OperationSpecification Pop(JToken value)
{
return new OperationSpecification
{
OperationType = OperationType.Pop,
Value = value
};
}
public static OperationSpecification Update(IDictionary dictionary)
{
return new OperationSpecification
{
OperationType = OperationType.Update,
Value = (JToken)(object)JObject.FromObject((object)dictionary)
};
}
public static OperationSpecification Floor()
{
return new OperationSpecification
{
OperationType = OperationType.Floor,
Value = null
};
}
public static OperationSpecification Ceiling()
{
return new OperationSpecification
{
OperationType = OperationType.Ceil,
Value = null
};
}
}
public static class Bitwise
{
public static OperationSpecification Xor(long i)
{
return new OperationSpecification
{
OperationType = OperationType.Xor,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Xor(BigInteger i)
{
return new OperationSpecification
{
OperationType = OperationType.Xor,
Value = JToken.Parse(i.ToString())
};
}
public static OperationSpecification Or(long i)
{
return new OperationSpecification
{
OperationType = OperationType.Or,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification Or(BigInteger i)
{
return new OperationSpecification
{
OperationType = OperationType.Or,
Value = JToken.Parse(i.ToString())
};
}
public static OperationSpecification And(long i)
{
return new OperationSpecification
{
OperationType = OperationType.And,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification And(BigInteger i)
{
return new OperationSpecification
{
OperationType = OperationType.And,
Value = JToken.Parse(i.ToString())
};
}
public static OperationSpecification LeftShift(long i)
{
return new OperationSpecification
{
OperationType = OperationType.LeftShift,
Value = JToken.op_Implicit(i)
};
}
public static OperationSpecification RightShift(long i)
{
return new OperationSpecification
{
OperationType = OperationType.RightShift,
Value = JToken.op_Implicit(i)
};
}
}
public class Callback
{
internal DataStorageHelper.DataStorageUpdatedHandler Method { get; set; }
private Callback()
{
}
public static Callback Add(DataStorageHelper.DataStorageUpdatedHandler callback)
{
return new Callback
{
Method = callback
};
}
}
public class AdditionalArgument
{
internal string Key { get; set; }
internal JToken Value { get; set; }
private AdditionalArgument()
{
}
public static AdditionalArgument Add(string name, JToken value)
{
return new AdditionalArgument
{
Key = name,
Value = value
};
}
}
public class MinimalSerializableItemInfo
{
public long ItemId { get; set; }
public long LocationId { get; set; }
public int PlayerSlot { get; set; }
public ItemFlags Flags { get; set; }
public string ItemGame { get; set; }
public string LocationGame { get; set; }
}
public class SerializableItemInfo : MinimalSerializableItemInfo
{
public bool IsScout { get; set; }
public PlayerInfo Player { get; set; }
public string ItemName { get; set; }
public string LocationName { get; set; }
[JsonIgnore]
public string ItemDisplayName => ItemName ?? $"Item: {base.ItemId}";
[JsonIgnore]
public string LocationDisplayName => LocationName ?? $"Location: {base.LocationId}";
public string ToJson(bool full = false)
{
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0071: Expected O, but got Unknown
MinimalSerializableItemInfo minimalSerializableItemInfo = this;
if (!full)
{
minimalSerializableItemInfo = new MinimalSerializableItemInfo
{
ItemId = base.ItemId,
LocationId = base.LocationId,
PlayerSlot = base.PlayerSlot,
Flags = base.Flags
};
if (IsScout)
{
minimalSerializableItemInfo.ItemGame = base.ItemGame;
}
else
{
minimalSerializableItemInfo.LocationGame = base.LocationGame;
}
}
JsonSerializerSettings val = new JsonSerializerSettings
{
NullValueHandling = (NullValueHandling)1,
Formatting = (Formatting)0
};
return JsonConvert.SerializeObject((object)minimalSerializableItemInfo, val);
}
public static SerializableItemInfo FromJson(string json, IArchipelagoSession session = null)
{
//IL_003c: Unknown result type (might be due to invalid IL or missing references)
//IL_0041: Unknown result type (might be due to invalid IL or missing references)
//IL_0050: Expected O, but got Unknown
ItemInfoStreamingContext additional = ((session != null) ? new ItemInfoStreamingContext
{
Items = session.Items,
Locations = session.Locations,
PlayerHelper = session.Players,
ConnectionInfo = session.ConnectionInfo
} : null);
JsonSerializerSettings val = new JsonSerializerSettings
{
Context = new StreamingContext(StreamingContextStates.Other, additional)
};
return JsonConvert.DeserializeObject<SerializableItemInfo>(json, val);
}
[OnDeserialized]
internal void OnDeserializedMethod(StreamingContext streamingContext)
{
if (base.ItemGame == null && base.LocationGame != null)
{
IsScout = false;
}
else if (base.ItemGame != null && base.LocationGame == null)
{
IsScout = true;
}
if (streamingContext.Context is ItemInfoStreamingContext itemInfoStreamingContext)
{
if (IsScout && base.LocationGame == null)
{
base.LocationGame = itemInfoStreamingContext.ConnectionInfo.Game;
}
else if (!IsScout && base.ItemGame == null)
{
base.ItemGame = itemInfoStreamingContext.ConnectionInfo.Game;
}
if (ItemName == null)
{
ItemName = itemInfoStreamingContext.Items.GetItemName(base.ItemId, base.ItemGame);
}
if (LocationName == null)
{
LocationName = itemInfoStreamingContext.Locations.GetLocationNameFromId(base.LocationId, base.LocationGame);
}
if (Player == null)
{
Player = itemInfoStreamingContext.PlayerHelper.GetPlayerInfo(base.PlayerSlot);
}
}
}
}
internal class ItemInfoStreamingContext
{
public IReceivedItemsHelper Items { get; set; }
public ILocationCheckHelper Locations { get; set; }
public IPlayerHelper PlayerHelper { get; set; }
public IConnectionInfoProvider ConnectionInfo { get; set; }
}
}
namespace Archipelago.MultiClient.Net.MessageLog.Parts
{
public class EntranceMessagePart : MessagePart
{
internal EntranceMessagePart(JsonMessagePart messagePart)
: base(MessagePartType.Entrance, messagePart, Archipelago.MultiClient.Net.Colors.PaletteColor.Blue)
{
base.Text = messagePart.Text;
}
}
public class HintStatusMessagePart : MessagePart
{
internal HintStatusMessagePart(JsonMessagePart messagePart)
: base(MessagePartType.HintStatus, messagePart)
{
base.Text = messagePart.Text;
if (messagePart.HintStatus.HasValue)
{
base.PaletteColor = ColorUtils.GetColor(messagePart.HintStatus.Value);
}
}
}
public class ItemMessagePart : MessagePart
{
public ItemFlags Flags { get; }
public long ItemId { get; }
public int Player { get; }
internal ItemMessagePart(IPlayerHelper players, IItemInfoResolver items, JsonMessagePart part)
: base(MessagePartType.Item, part)
{
Flags = part.Flags.GetValueOrDefault();
base.PaletteColor = ColorUtils.GetColor(Flags);
Player = part.Player.GetValueOrDefault();
string game = (players.GetPlayerInfo(Player) ?? new PlayerInfo()).Game;
JsonMessagePartType? type = part.Type;
if (type.HasValue)
{
switch (type.GetValueOrDefault())
{
case JsonMessagePartType.ItemId:
ItemId = long.Parse(part.Text);
base.Text = items.GetItemName(ItemId, game) ?? $"Item: {ItemId}";
break;
case JsonMessagePartType.ItemName:
ItemId = 0L;
base.Text = part.Text;
break;
}
}
}
}
public class LocationMessagePart : MessagePart
{
public long LocationId { get; }
public int Player { get; }
internal LocationMessagePart(IPlayerHelper players, IItemInfoResolver itemInfoResolver, JsonMessagePart part)
: base(MessagePartType.Location, part, Archipelago.MultiClient.Net.Colors.PaletteColor.Green)
{
Player = part.Player.GetValueOrDefault();
string game = (players.GetPlayerInfo(Player) ?? new PlayerInfo()).Game;
JsonMessagePartType? type = part.Type;
if (type.HasValue)
{
switch (type.GetValueOrDefault())
{
case JsonMessagePartType.LocationId:
LocationId = long.Parse(part.Text);
base.Text = itemInfoResolver.GetLocationName(LocationId, game) ?? $"Location: {LocationId}";
break;
case JsonMessagePartType.LocationName:
LocationId = itemInfoResolver.GetLocationId(part.Text, game);
base.Text = part.Text;
break;
}
}
}
}
public class MessagePart
{
public string Text { get; internal set; }
public MessagePartType Type { get; internal set; }
public Color Color => GetColor(BuiltInPalettes.Dark);
public PaletteColor? PaletteColor { get; protected set; }
public bool IsBackgroundColor { get; internal set; }
internal MessagePart(MessagePartType type, JsonMessagePart messagePart, PaletteColor? color = null)
{
Type = type;
Text = messagePart.Text;
if (color.HasValue)
{
PaletteColor = color.Value;
}
else if (messagePart.Color.HasValue)
{
PaletteColor = ColorUtils.GetColor(messagePart.Color.Value);
IsBackgroundColor = messagePart.Color.Value >= JsonMessagePartColor.BlackBg;
}
else
{
PaletteColor = null;
}
}
public T GetColor<T>(Palette<T> palette)
{
return palette[PaletteColor];
}
public override string ToString()
{
return Text;
}
}
public enum MessagePartType
{
Text,
Player,
Item,
Location,
Entrance,
HintStatus
}
public class PlayerMessagePart : MessagePart
{
public bool IsActivePlayer { get; }
public int SlotId { get; }
internal PlayerMessagePart(IPlayerHelper players, IConnectionInfoProvider connectionInfo, JsonMessagePart part)
: base(MessagePartType.Player, part)
{
switch (part.Type)
{
case JsonMessagePartType.PlayerId:
SlotId = int.Parse(part.Text);
IsActivePlayer = SlotId == connectionInfo.Slot;
base.Text = players.GetPlayerAlias(SlotId) ?? $"Player {SlotId}";
break;
case JsonMessagePartType.PlayerName:
SlotId = 0;
IsActivePlayer = false;
base.Text = part.Text;
break;
}
base.PaletteColor = (IsActivePlayer ? Archipelago.MultiClient.Net.Colors.PaletteColor.Magenta : Archipelago.MultiClient.Net.Colors.PaletteColor.Yellow);
}
}
}
namespace Archipelago.MultiClient.Net.MessageLog.Messages
{
public class AdminCommandResultLogMessage : LogMessage
{
internal AdminCommandResultLogMessage(MessagePart[] parts)
: base(parts)
{
}
}
public class ChatLogMessage : PlayerSpecificLogMessage
{
public string Message { get; }
internal ChatLogMessage(MessagePart[] parts, IPlayerHelper players, int team, int slot, string message)
: base(parts, players, team, slot)
{
Message = message;
}
}
public class CollectLogMessage : PlayerSpecificLogMessage
{
internal CollectLogMessage(MessagePart[] parts, IPlayerHelper players, int team, int slot)
: base(parts, players, team, slot)
{
}
}
public class CommandResultLogMessage : LogMessage
{
internal CommandResultLogMessage(MessagePart[] parts)
: base(parts)
{
}
}
public class CountdownLogMessage : LogMessage
{
public int RemainingSeconds { get; }
internal CountdownLogMessage(MessagePart[] parts, int remainingSeconds)
: base(parts)
{
RemainingSeconds = remainingSeconds;
}
}
public class GoalLogMessage : PlayerSpecificLogMessage
{
internal GoalLogMessage(MessagePart[] parts, IPlayerHelper players, int team, int slot)
: base(parts, players, team, slot)
{
}
}
public class HintItemSendLogMessage : ItemSendLogMessage
{
public bool IsFound { get; }
internal HintItemSendLogMessage(MessagePart[] parts, IPlayerHelper players, int receiver, int sender, NetworkItem item, bool found, IItemInfoResolver itemInfoResolver)
: base(parts, players, receiver, sender, item, itemInfoResolver)
{
IsFound = found;
}
}
public class ItemCheatLogMessage : ItemSendLogMessage
{
internal ItemCheatLogMessage(MessagePart[] parts, IPlayerHelper players, int team, int slot, NetworkItem item, IItemInfoResolver itemInfoResolver)
: base(parts, players, slot, 0, item, team, itemInfoResolver)
{
}
}
public class ItemSendLogMessage : LogMessage
{
private PlayerInfo ActivePlayer { get; }
public PlayerInfo Receiver { get; }
public PlayerInfo Sender { get; }
public bool IsReceiverTheActivePlayer => Receiver == ActivePlayer;
public bool IsSenderTheActivePlayer => Sender == ActivePlayer;
public bool IsRelatedToActivePlayer
{
get
{
if (!ActivePlayer.IsRelatedTo(Receiver))
{
return ActivePlayer.IsRelatedTo(Sender);
}
return true;
}
}
public ItemInfo Item { get; }
internal ItemSendLogMessage(MessagePart[] parts, IPlayerHelper players, int receiver, int sender, NetworkItem item, IItemInfoResolver itemInfoResolver)
: this(parts, players, receiver, sender, item, players.ActivePlayer.Team, itemInfoResolver)
{
}
internal ItemSendLogMessage(MessagePart[] parts, IPlayerHelper players, int receiver, int sender, NetworkItem item, int team, IItemInfoResolver itemInfoResolver)
: base(parts)
{
ActivePlayer = players.ActivePlayer ?? new PlayerInfo();
Receiver = players.GetPlayerInfo(team, receiver) ?? new PlayerInfo();
Sender = players.GetPlayerInfo(team, sender) ?? new PlayerInfo();
PlayerInfo player = players.GetPlayerInfo(team, item.Player) ?? new PlayerInfo();
Item = new ItemInfo(item, Receiver.Game, Sender.Game, itemInfoResolver, player);
}
}
public class JoinLogMessage : PlayerSpecificLogMessage
{
public string[] Tags { get; }
internal JoinLogMessage(MessagePart[] parts, IPlayerHelper players, int team, int slot, string[] tags)
: base(parts, players, team, slot)
{
Tags = tags;
}
}
public class LeaveLogMessage : PlayerSpecificLogMessage
{
internal LeaveLogMessage(MessagePart[] parts, IPlayerHelper players, int team, int slot)
: base(parts, players, team, slot)
{
}
}
public class LogMessage
{
public MessagePart[] Parts { get; }
internal LogMessage(MessagePart[] parts)
{
Parts = parts;
}
public override string ToString()
{
if (Parts.Length == 1)
{
return Parts[0].Text;
}
StringBuilder stringBuilder = new StringBuilder();
MessagePart[] parts = Parts;
foreach (MessagePart messagePart in parts)
{
stringBuilder.Append(messagePart.Text);
}
return stringBuilder.ToString();
}
}
public abstract class PlayerSpecificLogMessage : LogMessage
{
private PlayerInfo ActivePlayer { get; }
public PlayerInfo Player { get; }
public bool IsActivePlayer => Player == ActivePlayer;
public bool IsRelatedToActivePlayer => ActivePlayer.IsRelatedTo(Player);
internal PlayerSpecificLogMessage(MessagePart[] parts, IPlayerHelper players, int team, int slot)
: base(parts)
{
ActivePlayer = players.ActivePlayer ?? new PlayerInfo();
Player = players.GetPlayerInfo(team, slot) ?? new PlayerInfo();
}
}
public class ReleaseLogMessage : PlayerSpecificLogMessage
{
internal ReleaseLogMessage(MessagePart[] parts, IPlayerHelper players, int team, int slot)
: base(parts, players, team, slot)
{
}
}
public class ServerChatLogMessage : LogMessage
{
public string Message { get; }
internal ServerChatLogMessage(MessagePart[] parts, string message)
: base(parts)
{
Message = message;
}
}
public class TagsChangedLogMessage : PlayerSpecificLogMessage
{
public string[] Tags { get; }
internal TagsChangedLogMessage(MessagePart[] parts, IPlayerHelper players, int team, int slot, string[] tags)
: base(parts, players, team, slot)
{
Tags = tags;
}
}
public class TutorialLogMessage : LogMessage
{
internal TutorialLogMessage(MessagePart[] parts)
: base(parts)
{
}
}
}
namespace Archipelago.MultiClient.Net.Helpers
{
public class ArchipelagoSocketHelper : BaseArchipelagoSocketHelper<ClientWebSocket>, IArchipelagoSocketHelper
{
public Uri Uri { get; }
internal ArchipelagoSocketHelper(Uri hostUri)
: base(CreateWebSocket(), 1024)
{
Uri = hostUri;
}
private static ClientWebSocket CreateWebSocket()
{
return new ClientWebSocket();
}
public async Task ConnectAsync()
{
await ConnectToProvidedUri(Uri);
StartPolling();
}
private async Task ConnectToProvidedUri(Uri uri)
{
if (uri.Scheme != "unspecified")
{
try
{
await Socket.ConnectAsync(uri, CancellationToken.None);
return;
}
catch (Exception e)
{
OnError(e);
throw;
}
}
List<Exception> errors = new List<Exception>(0);
try
{
await Socket.ConnectAsync(uri.AsWss(), CancellationToken.None);
if (Socket.State == WebSocketState.Open)
{
return;
}
}
catch (Exception item)
{
errors.Add(item);
Socket = CreateWebSocket();
}
try
{
await Socket.ConnectAsync(uri.AsWs(), CancellationToken.None);
}
catch (Exception item2)
{
errors.Add(item2);
OnError(new AggregateException(errors));
throw;
}
}
}
public class BaseArchipelagoSocketHelper<T> where T : WebSocket
{
private static readonly ArchipelagoPacketConverter Converter = new ArchipelagoPacketConverter();
private readonly BlockingCollection<Tuple<ArchipelagoPacketBase, TaskCompletionSource<bool>>> sendQueue = new BlockingCollection<Tuple<ArchipelagoPacketBase, TaskCompletionSource<bool>>>();
internal T Socket;
private readonly int bufferSize;
public bool Connected
{
get
{
if (Socket.State != WebSocketState.Open)
{
return Socket.State == WebSocketState.CloseReceived;
}
return true;
}
}
public event ArchipelagoSocketHelperDelagates.PacketReceivedHandler PacketReceived;
public event ArchipelagoSocketHelperDelagates.PacketsSentHandler PacketsSent;
public event ArchipelagoSocketHelperDelagates.ErrorReceivedHandler ErrorReceived;
public event ArchipelagoSocketHelperDelagates.SocketClosedHandler SocketClosed;
public event ArchipelagoSocketHelperDelagates.SocketOpenedHandler SocketOpened;
internal BaseArchipelagoSocketHelper(T socket, int bufferSize = 1024)
{
Socket = socket;
this.bufferSize = bufferSize;
}
internal void StartPolling()
{
if (this.SocketOpened != null)
{
this.SocketOpened();
}
Task.Run((Func<Task?>)PollingLoop);
Task.Run((Func<Task?>)SendLoop);
}
private async Task PollingLoop()
{
byte[] buffer = new byte[bufferSize];
while (Socket.State == WebSocketState.Open)
{
string message = null;
try
{
message = await ReadMessageAsync(buffer);
}
catch (Exception e)
{
OnError(e);
}
OnMessageReceived(message);
}
}
private async Task SendLoop()
{
while (Socket.State == WebSocketState.Open)
{
try
{
await HandleSendBuffer();
}
catch (Exception e)
{
OnError(e);
}
await Task.Delay(20);
}
}
private async Task<string> ReadMessageAsync(byte[] buffer)
{
using MemoryStream readStream = new MemoryStream(buffer.Length);
WebSocketReceiveResult result;
do
{
result = await Socket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
if (result.MessageType == WebSocketMessageType.Close)
{
try
{
await Socket.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None);
}
catch
{
}
OnSocketClosed();
}
else
{
readStream.Write(buffer, 0, result.Count);
}
}
while (!result.EndOfMessage);
return Encoding.UTF8.GetString(readStream.ToArray());
}
public async Task DisconnectAsync()
{
await Socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closure requested by client", CancellationToken.None);
OnSocketClosed();
}
public void SendPacket(ArchipelagoPacketBase packet)
{
SendMultiplePackets(new List<ArchipelagoPacketBase> { packet });
}
public void SendMultiplePackets(List<ArchipelagoPacketBase> packets)
{
SendMultiplePackets(packets.ToArray());
}
public void SendMultiplePackets(params ArchipelagoPacketBase[] packets)
{
SendMultiplePacketsAsync(packets).Wait();
}
public Task SendPacketAsync(ArchipelagoPacketBase packet)
{
return SendMultiplePacketsAsync(new List<ArchipelagoPacketBase> { packet });
}
public Task SendMultiplePacketsAsync(List<ArchipelagoPacketBase> packets)
{
return SendMultiplePacketsAsync(packets.ToArray());
}
public Task SendMultiplePacketsAsync(params ArchipelagoPacketBase[] packets)
{
TaskCompletionSource<bool> taskCompletionSource = new TaskCompletionSource<bool>();
foreach (ArchipelagoPacketBase item in packets)
{
sendQueue.Add(new Tuple<ArchipelagoPacketBase, TaskCompletionSource<bool>>(item, taskCompletionSource));
}
return taskCompletionSource.Task;
}
private async Task HandleSendBuffer()
{
List<ArchipelagoPacketBase> list = new List<ArchipelagoPacketBase>();
List<TaskCompletionSource<bool>> tasks = new List<TaskCompletionSource<bool>>();
Tuple<ArchipelagoPacketBase, TaskCompletionSource<bool>> tuple = sendQueue.Take();
list.Add(tuple.Item1);
tasks.Add(tuple.Item2);
Tuple<ArchipelagoPacketBase, TaskCompletionSource<bool>> item;
while (sendQueue.TryTake(out item))
{
list.Add(item.Item1);
tasks.Add(item.Item2);
}
if (!list.Any())
{
return;
}
if (Socket.State != WebSocketState.Open)
{
throw new ArchipelagoSocketClosedException();
}
ArchipelagoPacketBase[] packets = list.ToArray();
string s = JsonConvert.SerializeObject((object)packets);
byte[] messageBuffer = Encoding.UTF8.GetBytes(s);
int messagesCount = (int)Math.Ceiling((double)messageBuffer.Length / (double)bufferSize);
for (int i = 0; i < messagesCount; i++)
{
int num = bufferSize * i;
int num2 = bufferSize;
bool endOfMessage = i + 1 == messagesCount;
if (num2 * (i + 1) > messageBuffer.Length)
{
num2 = messageBuffer.Length - num;
}
await Socket.SendAsync(new ArraySegment<byte>(messageBuffer, num, num2), WebSocketMessageType.Text, endOfMessage, CancellationToken.None);
}
foreach (TaskCompletionSource<bool> item2 in tasks)
{
item2.TrySetResult(result: true);
}
OnPacketSend(packets);
}
private void OnPacketSend(ArchipelagoPacketBase[] packets)
{
try
{
if (this.PacketsSent != null)
{
this.PacketsSent(packets);
}
}
catch (Exception e)
{
OnError(e);
}
}
private void OnSocketClosed()
{
try
{
if (this.SocketClosed != null)
{
this.SocketClosed("");
}
}
catch (Exception e)
{
OnError(e);
}
}
private void OnMessageReceived(string message)
{
try
{
if (string.IsNullOrEmpty(message) || this.PacketReceived == null)
{
return;
}
List<ArchipelagoPacketBase> list = null;
try
{
list = JsonConvert.DeserializeObject<List<ArchipelagoPacketBase>>(message, (JsonConverter[])(object)new JsonConverter[1] { Converter });
}
catch (Exception e)
{
OnError(e);
}
if (list == null)
{
return;
}
foreach (ArchipelagoPacketBase item in list)
{
this.PacketReceived(item);
}
}
catch (Exception e2)
{
OnError(e2);
}
}
protected void OnError(Exception e)
{
try
{
if (this.ErrorReceived != null)
{
this.ErrorReceived(e, e.Message);
}
}
catch (Exception ex)
{
Console.Out.WriteLine("Error occured during reporting of errorOuter Errror: " + e.Message + " " + e.StackTrace + "Inner Errror: " + ex.Message + " " + ex.StackTrace);
}
}
}
public interface IConnectionInfoProvider
{
string Game { get; }
int Team { get; }
int Slot { get; }
string[] Tags { get; }
ItemsHandlingFlags ItemsHandlingFlags { get; }
string Uuid { get; }
void UpdateConnectionOptions(string[] tags);
void UpdateConnectionOptions(ItemsHandlingFlags itemsHandlingFlags);
void UpdateConnectionOptions(string[] tags, ItemsHandlingFlags itemsHandlingFlags);
}
public class ConnectionInfoHelper : IConnectionInfoProvider
{
private readonly IArchipelagoSocketHelper socket;
public string Game { get; private set; }
public int Team { get; private set; }
public int Slot { get; private set; }
public string[] Tags { get; internal set; }
public ItemsHandlingFlags ItemsHandlingFlags { get; internal set; }
public string Uuid { get; private set; }
internal ConnectionInfoHelper(IArchipelagoSocketHelper socket)
{
this.socket = socket;
Reset();
socket.PacketReceived += PacketReceived;
}
private void PacketReceived(ArchipelagoPacketBase packet)
{
if (!(packet is ConnectedPacket connectedPacket))
{
if (packet is ConnectionRefusedPacket)
{
Reset();
}
return;
}
Team = connectedPacket.Team;
Slot = connectedPacket.Slot;
if (connectedPacket.SlotInfo != null && connectedPacket.SlotInfo.ContainsKey(Slot))
{
Game = connectedPacket.SlotInfo[Slot].Game;
}
}
internal void SetConnectionParameters(string game, string[] tags, ItemsHandlingFlags itemsHandlingFlags, string uuid)
{
Game = game;
Tags = tags ?? new string[0];
ItemsHandlingFlags = itemsHandlingFlags;
Uuid = uuid ?? Guid.NewGuid().ToString();
}
private void Reset()
{
Game = null;
Team = -1;
Slot = -1;
Tags = new string[0];
ItemsHandlingFlags = ItemsHandlingFlags.NoItems;
Uuid = null;
}
public void UpdateConnectionOptions(string[] tags)
{
UpdateConnectionOptions(tags, ItemsHandlingFlags);
}
public void UpdateConnectionOptions(ItemsHandlingFlags itemsHandlingFlags)
{
UpdateConnectionOptions(Tags, ItemsHandlingFlags);
}
public void UpdateConnectionOptions(string[] tags, ItemsHandlingFlags itemsHandlingFlags)
{
SetConnectionParameters(Game, tags, itemsHandlingFlags, Uuid);
socket.SendPacket(new ConnectUpdatePacket
{
Tags = Tags,
ItemsHandling = ItemsHandlingFlags
});
}
}
public interface IDataStorageHelper : IDataStorageWrapper
{
DataStorageElement this[Scope scope, string key] { get; set; }
DataStorageElement this[string key] { get; set; }
}
public class DataStorageHelper : IDataStorageHelper, IDataStorageWrapper
{
public delegate void DataStorageUpdatedHandler(JToken originalValue, JToken newValue, Dictionary<string, JToken> additionalArguments);
private readonly Dictionary<string, DataStorageUpdatedHandler> onValueChangedEventHandlers = new Dictionary<string, DataStorageUpdatedHandler>();
private readonly Dictionary<Guid, DataStorageUpdatedHandler> operationSpecificCallbacks = new Dictionary<Guid, DataStorageUpdatedHandler>();
private readonly Dictionary<string, TaskCompletionSource<JToken>> asyncRetrievalTasks = new Dictionary<string, TaskCompletionSource<JToken>>();
private readonly IArchipelagoSocketHelper socket;
private readonly IConnectionInfoProvider connectionInfoProvider;
public DataStorageElement this[Scope scope, string key]
{
get
{
return this[AddScope(scope, key)];
}
set
{
this[AddScope(scope, key)] = value;
}
}
public DataStorageElement this[string key]
{
get
{
return new DataStorageElement(GetContextForKey(key));
}
set
{
SetValue(key, value);
}
}
internal DataStorageHelper(IArchipelagoSocketHelper socket, IConnectionInfoProvider connectionInfoProvider)
{
this.socket = socket;
this.connectionInfoProvider = connectionInfoProvider;
socket.PacketReceived += OnPacketReceived;
}
private void OnPacketReceived(ArchipelagoPacketBase packet)
{
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b5: Invalid comparison between Unknown and I4
if (!(packet is RetrievedPacket retrievedPacket))
{
if (packet is SetReplyPacket setReplyPacket)
{
if (setReplyPacket.AdditionalArguments != null && setReplyPacket.AdditionalArguments.ContainsKey("Reference") && (int)setReplyPacket.AdditionalArguments["Reference"].Type == 15 && operationSpecificCallbacks.TryGetValue((Guid)setReplyPacket.AdditionalArguments["Reference"], out var value))
{
value(setReplyPacket.OriginalValue, setReplyPacket.Value, setReplyPacket.AdditionalArguments);
operationSpecificCallbacks.Remove((Guid)setReplyPacket.AdditionalArguments["Reference"]);
}
if (onValueChangedEventHandlers.TryGetValue(setReplyPacket.Key, out var value2))
{
value2(setReplyPacket.OriginalValue, setReplyPacket.Value, setReplyPacket.AdditionalArguments);
}
}
return;
}
foreach (KeyValuePair<string, JToken> datum in retrievedPacket.Data)
{
if (asyncRetrievalTasks.TryGetValue(datum.Key, out var value3))
{
value3.TrySetResult(datum.Value);
asyncRetrievalTasks.Remove(datum.Key);
}
}
}
private Task<JToken> GetAsync(string key)
{
if (asyncRetrievalTasks.TryGetValue(key, out var value))
{
return value.Task;
}
TaskCompletionSource<JToken> taskCompletionSource = new TaskCompletionSource<JToken>();
asyncRetrievalTasks[key] = taskCompletionSource;
socket.SendPacketAsync(new GetPacket
{
Keys = new string[1] { key }
});
return taskCompletionSource.Task;
}
private void Initialize(string key, JToken value)
{
socket.SendPacketAsync(new SetPacket
{
Key = key,
DefaultValue = value,
Operations = new OperationSpecification[1]
{
new OperationSpecification
{
OperationType = OperationType.Default
}
}
});
}
private JToken GetValue(string key)
{
Task<JToken> async = GetAsync(key);
if (!async.Wait(TimeSpan.FromSeconds(2.0)))
{
throw new TimeoutException("Timed out retrieving data for key `" + key + "`. This may be due to an attempt to retrieve a value from the DataStorageHelper in a synchronous fashion from within a PacketReceived handler. When using the DataStorageHelper from within code which runs on the websocket thread then use the asynchronous getters. Ex: `DataStorageHelper[\"" + key + "\"].GetAsync().ContinueWith(x => {});`Be aware that DataStorageHelper calls tend to cause packet responses, so making a call from within a PacketReceived handler may cause an infinite loop.");
}
return async.Result;
}
private void SetValue(string key, DataStorageElement e)
{
if (key.StartsWith("_read_"))
{
throw new InvalidOperationException("DataStorage write operation on readonly key '" + key + "' is not allowed");
}
if (e == null)
{
e = new DataStorageElement(OperationType.Replace, (JToken)(object)JValue.CreateNull());
}
if (e.Context == null)
{
e.Context = GetContextForKey(key);
}
else if (e.Context.Key != key)
{
e.Operations.Insert(0, new OperationSpecification
{
OperationType = OperationType.Replace,
Value = GetValue(e.Context.Key)
});
}
Dictionary<string, JToken> dictionary = e.AdditionalArguments ?? new Dictionary<string, JToken>(0);
if (e.Callbacks != null)
{
Guid guid = Guid.NewGuid();
operationSpecificCallbacks[guid] = e.Callbacks;
dictionary["Reference"] = JToken.FromObject((object)guid);
socket.SendPacketAsync(new SetPacket
{
Key = key,
Operations = e.Operations.ToArray(),
WantReply = true,
AdditionalArguments = dictionary
});
}
else
{
socket.SendPacketAsync(new SetPacket
{
Key = key,
Operations = e.Operations.ToArray(),
AdditionalArguments = dictionary
});
}
}
private DataStorageElementContext GetContextForKey(string key)
{
return new DataStorageElementContext
{
Key = key,
GetData = GetValue,
GetAsync = GetAsync,
Initialize = Initialize,
AddHandler = AddHandler,
RemoveHandler = RemoveHandler
};
}
private void AddHandler(string key, DataStorageUpdatedHandler handler)
{
if (onValueChangedEventHandlers.ContainsKey(key))
{
Dictionary<string, DataStorageUpdatedHandler> dictionary = onValueChangedEventHandlers;
dictionary[key] = (DataStorageUpdatedHandler)Delegate.Combine(dictionary[key], handler);
}
else
{
onValueChangedEventHandlers[key] = handler;
}
socket.SendPacketAsync(new SetNotifyPacket
{
Keys = new string[1] { key }
});
}
private void RemoveHandler(string key, DataStorageUpdatedHandler handler)
{
if (onValueChangedEventHandlers.ContainsKey(key))
{
Dictionary<string, DataStorageUpdatedHandler> dictionary = onValueChangedEventHandlers;
dictionary[key] = (DataStorageUpdatedHandler)Delegate.Remove(dictionary[key], handler);
if (onValueChangedEventHandlers[key] == null)
{
onValueChangedEventHandlers.Remove(key);
}
}
}
private string AddScope(Scope scope, string key)
{
return scope switch
{
Scope.Global => key,
Scope.Game => $"{scope}:{connectionInfoProvider.Game}:{key}",
Scope.Team => $"{scope}:{connectionInfoProvider.Team}:{key}",
Scope.Slot => $"{scope}:{connectionInfoProvider.Slot}:{key}",
Scope.ReadOnly => "_read_" + key,
_ => throw new ArgumentOutOfRangeException("scope", scope, "Invalid scope for key " + key),
};
}
private DataStorageElement GetHintsElement(int? slot = null, int? team = null)
{
return this[Scope.ReadOnly, $"hints_{team ?? connectionInfoProvider.Team}_{slot ?? connectionInfoProvider.Slot}"];
}
private DataStorageElement GetSlotDataElement(int? slot = null)
{
return this[Scope.ReadOnly, $"slot_data_{slot ?? connectionInfoProvider.Slot}"];
}
private DataStorageElement GetItemNameGroupsElement(string game = null)
{
return this[Scope.ReadOnly, "item_name_groups_" + (game ?? connectionInfoProvider.Game)];
}
private DataStorageElement GetLocationNameGroupsElement(string game = null)
{
return this[Scope.ReadOnly, "location_name_groups_" + (game ?? connectionInfoProvider.Game)];
}
private DataStorageElement GetClientStatusElement(int? slot = null, int? team = null)
{
return this[Scope.ReadOnly, $"client_status_{team ?? connectionInfoProvider.Team}_{slot ?? connectionInfoProvider.Slot}"];
}
private DataStorageElement GetRaceModeElement()
{
return this[Scope.ReadOnly, "race_mode"];
}
public Hint[] GetHints(int? slot = null, int? team = null)
{
return GetHintsElement(slot, team).To<Hint[]>();
}
public Task<Hint[]> GetHintsAsync(int? slot = null, int? team = null)
{
return GetHintsElement(slot, team).GetAsync<Hint[]>();
}
public void TrackHints(Action<Hint[]> onHintsUpdated, bool retrieveCurrentlyUnlockedHints = true, int? slot = null, int? team = null)
{
GetHintsElement(slot, team).OnValueChanged += delegate(JToken _, JToken newValue, Dictionary<string, JToken> x)
{
onHintsUpdated(newValue.ToObject<Hint[]>());
};
if (retrieveCurrentlyUnlockedHints)
{
GetHintsAsync(slot, team).ContinueWith(delegate(Task<Hint[]> t)
{
onHintsUpdated(t.Result);
});
}
}
public Dictionary<string, object> GetSlotData(int? slot = null)
{
return GetSlotData<Dictionary<string, object>>(slot);
}
public T GetSlotData<T>(int? slot = null) where T : class
{
return GetSlotDataElement(slot).To<T>();
}
public Task<Dictionary<string, object>> GetSlotDataAsync(int? slot = null)
{
return GetSlotDataAsync<Dictionary<string, object>>(slot);
}
public Task<T> GetSlotDataAsync<T>(int? slot = null) where T : class
{
return GetSlotDataElement(slot).GetAsync<T>();
}
public Dictionary<string, string[]> GetItemNameGroups(string game = null)
{
return GetItemNameGroupsElement(game).To<Dictionary<string, string[]>>();
}
public Task<Dictionary<string, string[]>> GetItemNameGroupsAsync(string game = null)
{
return GetItemNameGroupsElement(game).GetAsync<Dictionary<string, string[]>>();
}
public Dictionary<string, string[]> GetLocationNameGroups(string game = null)
{
return GetLocationNameGroupsElement(game).To<Dictionary<string, string[]>>();
}
public Task<Dictionary<string, string[]>> GetLocationNameGroupsAsync(string game = null)
{
return GetLocationNameGroupsElement(game).GetAsync<Dictionary<string, string[]>>();
}
public ArchipelagoClientState GetClientStatus(int? slot = null, int? team = null)
{
return GetClientStatusElement(slot, team).To<ArchipelagoClientState?>().GetValueOrDefault();
}
public Task<ArchipelagoClientState> GetClientStatusAsync(int? slot = null, int? team = null)
{
return GetClientStatusElement(slot, team).GetAsync<ArchipelagoClientState?>().ContinueWith((Task<ArchipelagoClientState?> r) => r.Result.GetValueOrDefault());
}
public void TrackClientStatus(Action<ArchipelagoClientState> onStatusUpdated, bool retrieveCurrentClientStatus = true, int? slot = null, int? team = null)
{
GetClientStatusElement(slot, team).OnValueChanged += delegate(JToken _, JToken newValue, Dictionary<string, JToken> x)
{using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading;
using Archipelago.MultiClient.Net;
using Archipelago.MultiClient.Net.BounceFeatures.DeathLink;
using Archipelago.MultiClient.Net.Enums;
using Archipelago.MultiClient.Net.Exceptions;
using Archipelago.MultiClient.Net.Helpers;
using Archipelago.MultiClient.Net.MessageLog.Messages;
using Archipelago.MultiClient.Net.MessageLog.Parts;
using Archipelago.MultiClient.Net.Models;
using Archipelago.MultiClient.Net.Packets;
using Archipelago.RiskOfRain2.Console;
using Archipelago.RiskOfRain2.Extensions;
using Archipelago.RiskOfRain2.Handlers;
using Archipelago.RiskOfRain2.Lookup;
using Archipelago.RiskOfRain2.Net;
using Archipelago.RiskOfRain2.UI;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using EntityStates;
using EntityStates.Interactables.MSObelisk;
using EntityStates.LunarTeleporter;
using EntityStates.ScavBackpack;
using HG;
using KinematicCharacterController;
using Microsoft.CodeAnalysis;
using On.EntityStates.Interactables.MSObelisk;
using On.EntityStates.LunarTeleporter;
using On.EntityStates.ScavBackpack;
using On.RoR2;
using On.RoR2.Artifacts;
using On.RoR2.UI;
using R2API.Networking;
using R2API.Networking.Interfaces;
using R2API.Utils;
using RoR2;
using RoR2.Networking;
using RoR2.UI;
using TMPro;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.ResourceManagement.AsyncOperations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Archipelago.RiskOfRain2")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.5.3.0")]
[assembly: AssemblyInformationalVersion("1.5.3+de03b9bbf542aae26dbb1819c5e5ec0dbe29d6c5")]
[assembly: AssemblyProduct("Archipelago.RiskOfRain2")]
[assembly: AssemblyTitle("Archipelago.RiskOfRain2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.5.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace Archipelago.RiskOfRain2
{
public class ArchipelagoClient : IDisposable
{
public delegate void ClientDisconnected(string reason);
public delegate void ReleaseClick(bool prompt);
public delegate void CollectClick(bool prompt);
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static UnityAction <>9__86_0;
public static UnityAction <>9__86_1;
public static UnityAction <>9__86_2;
public static UnityAction <>9__86_3;
internal void <GameEndReportPanelController_Awake>b__86_0()
{
OnReleaseClick(prompt: true);
}
internal void <GameEndReportPanelController_Awake>b__86_1()
{
OnReleaseClick(prompt: false);
}
internal void <GameEndReportPanelController_Awake>b__86_2()
{
OnCollectClick(prompt: true);
}
internal void <GameEndReportPanelController_Awake>b__86_3()
{
OnCollectClick(prompt: false);
}
}
[CompilerGenerated]
private sealed class <AttemptReconnection>d__79 : IEnumerator<WaitForSeconds>, System.Collections.IEnumerator, IDisposable
{
private int <>1__state;
private WaitForSeconds <>2__current;
public ArchipelagoClient <>4__this;
private int <retryCounter>5__1;
WaitForSeconds IEnumerator<WaitForSeconds>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object System.Collections.IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <AttemptReconnection>d__79(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_007c: Unknown result type (might be due to invalid IL or missing references)
//IL_0086: Expected O, but got Unknown
//IL_012f: Unknown result type (might be due to invalid IL or missing references)
//IL_017d: Unknown result type (might be due to invalid IL or missing references)
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
Log.LogDebug("Attempting to reconnect!");
<retryCounter>5__1 = 0;
if (!isInGame)
{
ArchipelagoConnectButtonController.ChangeButtonWhenDisconnected();
}
break;
case 1:
<>1__state = -1;
<>4__this.Connect(<>4__this.lastServerUrl, <>4__this.lastSlotName, <>4__this.lastPassword);
break;
}
if ((<>4__this.session == null || !<>4__this.session.Socket.Connected) && <retryCounter>5__1 < 5)
{
ChatMessage.Send($"Connection attempt #{<retryCounter>5__1 + 1}");
<retryCounter>5__1++;
<>2__current = new WaitForSeconds(3f);
<>1__state = 1;
return true;
}
if (<>4__this.session == null || !<>4__this.session.Socket.Connected)
{
ChatMessage.SendColored("Could not connect to Archipelago.", Color.red);
<>4__this.Dispose();
}
else if (<>4__this.session != null && <>4__this.session.Socket.Connected)
{
ChatMessage.SendColored("Established Archipelago connection.", Color.green);
NetMessageExtensions.Send((INetMessage)(object)new ArchipelagoStartMessage(), (NetworkDestination)1);
if (<>4__this.Locationhandler != null && isInGame)
{
<>4__this.Locationhandler.CatchUpSceneLocations(LocationHandler.sceneDef.cachedName);
<>4__this.Locationhandler.LoadItemPickupHooks();
}
}
<>4__this.reconnecting = false;
return false;
}
bool System.Collections.IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void System.Collections.IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
public ArchipelagoItemLogicController ItemLogic;
public ArchipelagoLocationCheckProgressBarUI itemCheckBar;
public ArchipelagoLocationCheckProgressBarUI shrineCheckBar;
private ArchipelagoSession session;
private DeathLinkService deathLinkService;
private bool finalStageDeath = false;
private bool isEndingAcceptable = false;
public GameObject ReleasePanel;
public GameObject CollectPanel;
public GameObject ReleasePromptPanel;
public GameObject CollectPromptPanel;
public static ReleaseClick OnReleaseClick;
public static CollectClick OnCollectClick;
private GameObject genericMenuButton;
public static string connectedPlayerName;
public static string victoryCondition;
private GameEndingDef[] acceptableEndings;
private string[] acceptableLosses;
public string lastServerUrl { get; set; }
public string lastSlotName { get; set; }
public string lastPassword { get; set; }
internal DeathLinkHandler Deathlinkhandler { get; private set; }
internal StageBlockerHandler Stageblockerhandler { get; private set; }
internal LocationHandler Locationhandler { get; private set; }
internal ShrineChanceHandler shrineChanceHelper { get; private set; }
public bool reconnecting { get; set; } = false;
public static int lastReceivedItemindex { get; set; }
public static bool isInGame { get; set; }
public event ClientDisconnected OnClientDisconnect;
public void Connect(string url, string slotName, string password = null)
{
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_0158: Expected O, but got Unknown
//IL_0103: Unknown result type (might be due to invalid IL or missing references)
//IL_010a: Expected O, but got Unknown
//IL_0188: Unknown result type (might be due to invalid IL or missing references)
//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
//IL_0123: Unknown result type (might be due to invalid IL or missing references)
//IL_0398: Unknown result type (might be due to invalid IL or missing references)
//IL_039d: Unknown result type (might be due to invalid IL or missing references)
//IL_03bc: Unknown result type (might be due to invalid IL or missing references)
//IL_03cb: Unknown result type (might be due to invalid IL or missing references)
//IL_0733: Unknown result type (might be due to invalid IL or missing references)
//IL_073d: Expected O, but got Unknown
//IL_0750: Unknown result type (might be due to invalid IL or missing references)
//IL_075a: Expected O, but got Unknown
//IL_0779: Unknown result type (might be due to invalid IL or missing references)
//IL_077e: Unknown result type (might be due to invalid IL or missing references)
//IL_06be: Unknown result type (might be due to invalid IL or missing references)
//IL_06c3: Unknown result type (might be due to invalid IL or missing references)
if (session != null && session.Socket.Connected)
{
Disconnect();
return;
}
isEndingAcceptable = false;
ChatMessage.SendColored("Attempting to connect to Archipelago at " + url + ".", Color.green);
lastServerUrl = url;
lastSlotName = slotName;
lastPassword = password;
try
{
session = ArchipelagoSessionFactory.CreateSession(url, 38281);
}
catch (Exception ex)
{
this.OnClientDisconnect(ex.Message);
}
ItemLogic = new ArchipelagoItemLogicController(session);
itemCheckBar = null;
shrineCheckBar = null;
if (!isInGame)
{
lastReceivedItemindex = 0;
}
LoginResult val = session.TryConnectAndLogin("Risk of Rain 2", slotName, (ItemsHandlingFlags)7, new Version(0, 6, 4), (string[])null, (string)null, password, true);
if (!val.Successful)
{
LoginFailure val2 = (LoginFailure)val;
string[] errors = val2.Errors;
foreach (string text in errors)
{
ChatMessage.SendColored(text, Color.red);
Log.LogError(text);
}
Dispose();
return;
}
LoginSuccessful val3 = (LoginSuccessful)val;
ArchipelagoConnectButtonController.ChangeButtonWhenConnected();
object value2;
if (val3.SlotData.TryGetValue("finalStageDeath", out var value))
{
finalStageDeath = Convert.ToBoolean(value);
ChatMessage.SendColored("Connected!", Color.green);
}
else if (val3.SlotData.TryGetValue("FinalStageDeath", out value2))
{
finalStageDeath = Convert.ToBoolean(value2);
ChatMessage.SendColored("Connected!", Color.green);
}
Log.LogDebug($"finalStageDeath {finalStageDeath} ");
uint itemPickupStep = 3u;
uint num = 3u;
if (val3.SlotData.TryGetValue("itemPickupStep", out var value3))
{
itemPickupStep = Convert.ToUInt32(value3);
Log.LogDebug($"itemPickupStep from slot data: {itemPickupStep}");
itemPickupStep++;
}
if (val3.SlotData.TryGetValue("shrineUseStep", out var value4))
{
num = Convert.ToUInt32(value4);
Log.LogDebug($"shrineUseStep from slot data: {num}");
num++;
}
deathLinkService = DeathLinkProvider.CreateDeathLinkService(session);
Log.LogDebug("Starting DeathLink service");
Deathlinkhandler = new DeathLinkHandler(deathLinkService);
if (val3.SlotData.TryGetValue("deathLink", out var value5) && Convert.ToBoolean(value5))
{
deathLinkService.EnableDeathLink();
Deathlinkhandler?.Hook();
}
if (val3.SlotData.TryGetValue("goal", out var value6))
{
if (!Convert.ToBoolean(value6))
{
Log.LogDebug("Client detected classic_mode");
ArchipelagoLocationsInEnvironmentController.RemoveObjective();
NetMessageExtensions.Send((INetMessage)(object)new AllChecksCompleteInStage(), (NetworkDestination)1);
}
else
{
Log.LogDebug("Client detected explore_mode");
Stageblockerhandler = new StageBlockerHandler();
ItemLogic.Stageblockerhandler = Stageblockerhandler;
Stageblockerhandler.BlockAll();
Locationhandler = new LocationHandler(session, LocationHandler.buildTemplateFromSlotData(val3.SlotData));
shrineChanceHelper = new ShrineChanceHandler();
itemCheckBar = new ArchipelagoLocationCheckProgressBarUI(new Vector2(-40f, 0f), Vector2.zero, "Item Check Progress:");
shrineCheckBar = new ArchipelagoLocationCheckProgressBarUI(new Vector2(0f, 170f), new Vector2(50f, -50f), "Shrine Check Progress:");
shrineCheckBar.ItemPickupStep = (int)num;
Locationhandler.itemBar = itemCheckBar;
Locationhandler.shrineBar = shrineCheckBar;
Locationhandler.itemPickupStep = itemPickupStep;
Locationhandler.shrineUseStep = num;
}
}
if (val3.SlotData.TryGetValue("progressiveStages", out var value7))
{
StageBlockerHandler.progressivesStages = Convert.ToBoolean(value7);
}
if (val3.SlotData.TryGetValue("showSeerPortals", out var value8))
{
StageBlockerHandler.showSeerPortals = Convert.ToBoolean(value8);
}
if (val3.SlotData.TryGetValue("victory", out var value9))
{
switch (value9.ToString())
{
case "1":
acceptableEndings = (GameEndingDef[])(object)new GameEndingDef[1] { GameEndings.MainEnding };
acceptableLosses = new string[2] { "moon", "moon2" };
victoryCondition = "Mithrix";
break;
case "2":
acceptableEndings = (GameEndingDef[])(object)new GameEndingDef[1] { GameEndings.VoidEnding };
acceptableLosses = new string[1] { "voidraid" };
victoryCondition = "Voidling";
break;
case "3":
acceptableEndings = (GameEndingDef[])(object)new GameEndingDef[1] { GameEndings.LimboEnding };
acceptableLosses = new string[2] { "mysteryspace", "limbo" };
victoryCondition = "Limbo";
break;
case "4":
acceptableEndings = (GameEndingDef[])(object)new GameEndingDef[1] { GameEndings.RebirthEndingDef };
victoryCondition = "Rebirth";
break;
default:
victoryCondition = "any";
acceptableEndings = (GameEndingDef[])(object)new GameEndingDef[4]
{
GameEndings.MainEnding,
GameEndings.LimboEnding,
GameEndings.VoidEnding,
GameEndings.RebirthEndingDef
};
acceptableLosses = new string[6] { "moon", "moon2", "voidraid", "mysteryspace", "limbo", "meridian" };
break;
}
}
else
{
victoryCondition = "any";
acceptableEndings = (GameEndingDef[])(object)new GameEndingDef[4]
{
GameEndings.MainEnding,
GameEndings.LimboEnding,
GameEndings.VoidEnding,
GameEndings.RebirthEndingDef
};
acceptableLosses = new string[6] { "moon", "moon2", "voidraid", "mysteryspace", "limbo", "meridian" };
}
if (itemCheckBar == null)
{
Log.LogDebug("Setting up bar for classic");
itemCheckBar = new ArchipelagoLocationCheckProgressBarUI(Vector2.zero, Vector2.zero);
SyncLocationCheckProgress.OnLocationSynced += itemCheckBar.UpdateCheckProgress;
}
connectedPlayerName = session.Players.GetPlayerName(session.ConnectionInfo.Slot);
itemCheckBar.ItemPickupStep = (int)itemPickupStep;
session.MessageLog.OnMessageReceived += new MessageReceivedHandler(Session_OnMessageReceived);
session.Socket.SocketClosed += new SocketClosedHandler(Session_SocketClosed);
ItemLogic.OnItemDropProcessed += ItemLogicHandler_ItemDropProcessed;
genericMenuButton = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/UI/GenericMenuButton.prefab").WaitForCompletion();
HookGame();
NetMessageExtensions.Send((INetMessage)(object)new ArchipelagoStartMessage(), (NetworkDestination)1);
if (!Convert.ToBoolean(value6))
{
NetMessageExtensions.Send((INetMessage)(object)new ArchipelagoStartClassic(), (NetworkDestination)1);
}
else
{
NetMessageExtensions.Send((INetMessage)(object)new ArchipelagoStartExplore(), (NetworkDestination)1);
}
ItemLogic.Precollect();
if (session.Items.GetItemName(37501L, (string)null) == null)
{
StageBlockerHandler.stageUnlocks["Stage 1"] = true;
StageBlockerHandler.stageUnlocks["Stage 2"] = true;
StageBlockerHandler.stageUnlocks["Stage 3"] = true;
StageBlockerHandler.stageUnlocks["Stage 4"] = true;
}
else if (!isInGame)
{
StageBlockerHandler.stageUnlocks["Stage 1"] = false;
StageBlockerHandler.stageUnlocks["Stage 2"] = false;
StageBlockerHandler.stageUnlocks["Stage 3"] = false;
StageBlockerHandler.stageUnlocks["Stage 4"] = false;
}
}
public void Dispose()
{
if (ItemLogic != null)
{
ItemLogic.OnItemDropProcessed -= ItemLogicHandler_ItemDropProcessed;
ItemLogic.Dispose();
}
if (itemCheckBar != null)
{
SyncLocationCheckProgress.OnLocationSynced -= itemCheckBar.UpdateCheckProgress;
itemCheckBar.Dispose();
}
if (shrineCheckBar != null)
{
shrineCheckBar.Dispose();
}
UnhookGame();
session = null;
Stageblockerhandler = null;
Locationhandler = null;
itemCheckBar = null;
shrineCheckBar = null;
}
private void HookGame()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_007a: Expected O, but got Unknown
//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
//IL_00cc: Expected O, but got Unknown
//IL_014b: Unknown result type (might be due to invalid IL or missing references)
//IL_0155: Expected O, but got Unknown
//IL_015d: Unknown result type (might be due to invalid IL or missing references)
//IL_0167: Expected O, but got Unknown
ChatBox.SubmitChat += new hook_SubmitChat(ChatBox_SubmitChat);
Run.onRunDestroyGlobal += Run_onRunDestroyGlobal;
Run.BeginGameOver += new hook_BeginGameOver(Run_BeginGameOver);
ArchipelagoChatMessage.OnChatReceivedFromClient += ArchipelagoChatMessage_OnChatReceivedFromClient;
ReleasePanel = AssetBundleHelper.LoadPrefab("ReleasePrompt");
CollectPanel = AssetBundleHelper.LoadPrefab("CollectPrompt");
GameEndReportPanelController.Awake += new hook_Awake(GameEndReportPanelController_Awake);
OnReleaseClick = (ReleaseClick)Delegate.Combine(OnReleaseClick, new ReleaseClick(WillRelease));
OnCollectClick = (CollectClick)Delegate.Combine(OnCollectClick, new CollectClick(WillCollect));
SceneObjectToggleGroup.Awake += new hook_Awake(SceneObjectToggleGroup_Awake);
Stageblockerhandler?.Hook();
Locationhandler?.Hook();
shrineChanceHelper?.Hook();
ArchipelagoConsoleCommand.OnArchipelagoDeathLinkCommandCalled += ArchipelagoConsoleCommand_OnArchipelagoDeathLinkCommandCalled;
ArchipelagoConsoleCommand.OnArchipelagoFinalStageDeathCommandCalled += ArchipelagoConsoleCommand_OnArchipelagoFinalStageDeathCommandCalled;
ArchipelagoConsoleCommand.OnArchipelagoReconnectCommandCalled += ArchipelagoConsoleCommand_OnArchipelagoReconnectCommandCalled;
session.Socket.ErrorReceived += new ErrorReceivedHandler(Socket_ErrorReceived);
PortalDialerPreDialState.OnEnter += new hook_OnEnter(PortalDialerPreDialState_OnEnter);
}
private void PortalDialerPreDialState_OnEnter(orig_OnEnter orig, PortalDialerPreDialState self)
{
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
ChatMessage.SendColored("Victory conditon is " + victoryCondition + ".", Color.magenta);
orig.Invoke(self);
}
private void UnhookGame()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_0065: Expected O, but got Unknown
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_0082: Expected O, but got Unknown
//IL_008a: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Expected O, but got Unknown
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Expected O, but got Unknown
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
//IL_016f: Expected O, but got Unknown
//IL_0177: Unknown result type (might be due to invalid IL or missing references)
//IL_0181: Expected O, but got Unknown
ChatBox.SubmitChat -= new hook_SubmitChat(ChatBox_SubmitChat);
Run.onRunDestroyGlobal -= Run_onRunDestroyGlobal;
Run.BeginGameOver -= new hook_BeginGameOver(Run_BeginGameOver);
ArchipelagoChatMessage.OnChatReceivedFromClient -= ArchipelagoChatMessage_OnChatReceivedFromClient;
session.MessageLog.OnMessageReceived -= new MessageReceivedHandler(Session_OnMessageReceived);
session.Socket.SocketClosed -= new SocketClosedHandler(Session_SocketClosed);
GameEndReportPanelController.Awake -= new hook_Awake(GameEndReportPanelController_Awake);
OnReleaseClick = (ReleaseClick)Delegate.Remove(OnReleaseClick, new ReleaseClick(WillRelease));
OnCollectClick = (CollectClick)Delegate.Remove(OnCollectClick, new CollectClick(WillCollect));
SceneObjectToggleGroup.Awake -= new hook_Awake(SceneObjectToggleGroup_Awake);
Deathlinkhandler?.UnHook();
Stageblockerhandler?.UnHook();
Locationhandler?.UnHook();
shrineChanceHelper?.UnHook();
ArchipelagoConsoleCommand.OnArchipelagoDeathLinkCommandCalled -= ArchipelagoConsoleCommand_OnArchipelagoDeathLinkCommandCalled;
ArchipelagoConsoleCommand.OnArchipelagoFinalStageDeathCommandCalled -= ArchipelagoConsoleCommand_OnArchipelagoFinalStageDeathCommandCalled;
session.Socket.ErrorReceived -= new ErrorReceivedHandler(Socket_ErrorReceived);
PortalDialerPreDialState.OnEnter -= new hook_OnEnter(PortalDialerPreDialState_OnEnter);
}
private void SceneObjectToggleGroup_Awake(orig_Awake orig, SceneObjectToggleGroup self)
{
Log.LogDebug($"Scene group length {self.toggleGroups.Length}");
if (self.toggleGroups != null)
{
for (int i = 0; i < self.toggleGroups.Length; i++)
{
if (self.toggleGroups[i].objects != null && (Object)(object)self.toggleGroups[i].objects[0] != (Object)null && (((Object)self.toggleGroups[i].objects[0]).name == "NewtStatue" || ((Object)self.toggleGroups[i].objects[0]).name == "NewtStatue (1)"))
{
Log.LogDebug($"Scene Object Toggle Group min:{self.toggleGroups[i].minEnabled} max:{self.toggleGroups[i].maxEnabled}");
Log.LogDebug("Changing newt alters min and max values");
self.toggleGroups[i].minEnabled = 1;
self.toggleGroups[i].maxEnabled = 2;
Log.LogDebug($"Scene Object Toggle Group min:{self.toggleGroups[i].minEnabled} max:{self.toggleGroups[i].maxEnabled}");
break;
}
}
}
orig.Invoke(self);
}
private void ArchipelagoConsoleCommand_OnArchipelagoDeathLinkCommandCalled(bool link)
{
if (link)
{
Deathlinkhandler?.Hook();
deathLinkService.EnableDeathLink();
}
else
{
Deathlinkhandler?.UnHook();
deathLinkService.DisableDeathLink();
}
}
private void ArchipelagoConsoleCommand_OnArchipelagoFinalStageDeathCommandCalled(bool finalstage)
{
finalStageDeath = finalstage;
}
private void ArchipelagoChatMessage_OnChatReceivedFromClient(string message)
{
//IL_0024: Unknown result type (might be due to invalid IL or missing references)
//IL_002a: Expected O, but got Unknown
if (session.Socket.Connected && !string.IsNullOrEmpty(message))
{
SayPacket val = new SayPacket();
val.Text = message;
session.Socket.SendPacketAsync((ArchipelagoPacketBase)(object)val);
}
}
private void ArchipelagoConsoleCommand_OnArchipelagoReconnectCommandCalled()
{
reconnecting = true;
Session_SocketClosed("Making sure to be disconnected before reconnecting.");
}
private void ItemLogicHandler_ItemDropProcessed(int pickedUpCount)
{
if (itemCheckBar != null)
{
itemCheckBar.CurrentItemCount = pickedUpCount;
if (itemCheckBar.CurrentItemCount % ItemLogic.ItemPickupStep == 0)
{
itemCheckBar.CurrentItemCount = 0;
}
else
{
itemCheckBar.CurrentItemCount %= ItemLogic.ItemPickupStep;
}
}
NetMessageExtensions.Send((INetMessage)(object)new SyncLocationCheckProgress(itemCheckBar.CurrentItemCount, itemCheckBar.ItemPickupStep), (NetworkDestination)1);
}
private void ChatBox_SubmitChat(orig_SubmitChat orig, ChatBox self)
{
//IL_0030: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
string text = self.inputField.text;
if (session.Socket.Connected && !string.IsNullOrEmpty(text))
{
SayPacket val = new SayPacket();
val.Text = text;
session.Socket.SendPacketAsync((ArchipelagoPacketBase)(object)val);
self.inputField.text = string.Empty;
orig.Invoke(self);
}
else
{
orig.Invoke(self);
}
}
private void Socket_ErrorReceived(Exception e, string message)
{
Log.LogDebug($"Error received: {e}, message: {message}");
reconnecting = true;
Session_SocketClosed(message);
}
private void Session_SocketClosed(string reason)
{
Dispose();
NetMessageExtensions.Send((INetMessage)(object)new ArchipelagoEndMessage(), (NetworkDestination)1);
if (this.OnClientDisconnect != null)
{
this.OnClientDisconnect(reason);
}
}
[IteratorStateMachine(typeof(<AttemptReconnection>d__79))]
public IEnumerator<WaitForSeconds> AttemptReconnection()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <AttemptReconnection>d__79(0)
{
<>4__this = this
};
}
private void Session_OnMessageReceived(LogMessage message)
{
Thread thread = new Thread((ThreadStart)delegate
{
Session_OnMessageReceived_Thread(message);
});
thread.Start();
Thread.Sleep(20);
}
private void Session_OnMessageReceived_Thread(LogMessage message)
{
//IL_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: 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_003e: 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)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
string text = "";
MessagePart[] parts = message.Parts;
foreach (MessagePart val in parts)
{
Color color = val.Color;
string text2 = ((Color)(ref color)).R.ToString("X2");
color = val.Color;
string text3 = ((Color)(ref color)).G.ToString("X2");
color = val.Color;
string text4 = text2 + text3 + ((Color)(ref color)).B.ToString("X2");
text = text + "<color=#" + text4 + ">" + ((object)val)?.ToString() + "</color>";
}
ChatMessage.Send(text);
}
private void Run_BeginGameOver(orig_BeginGameOver orig, Run self, GameEndingDef gameEndingDef)
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Expected O, but got Unknown
if (IsEndingAcceptable(gameEndingDef))
{
isEndingAcceptable = true;
StatusUpdatePacket val = new StatusUpdatePacket();
val.Status = (ArchipelagoClientState)30;
session.Socket.SendPacketAsync((ArchipelagoPacketBase)(object)val);
NetMessageExtensions.Send((INetMessage)(object)new ArchipelagoEndMessage(), (NetworkDestination)1);
}
orig.Invoke(self, gameEndingDef);
}
private bool IsEndingAcceptable(GameEndingDef gameEndingDef)
{
Log.LogDebug("ending stage is " + Stage.instance.sceneDef.cachedName);
return acceptableEndings.Contains(gameEndingDef) || (finalStageDeath && (Object)(object)gameEndingDef == (Object)(object)GameEndings.StandardLoss && acceptableLosses.Contains(Stage.instance.sceneDef.cachedName)) || (finalStageDeath && (Object)(object)gameEndingDef == (Object)(object)GameEndings.ObliterationEnding && acceptableLosses.Contains(Stage.instance.sceneDef.cachedName));
}
private void Run_onRunDestroyGlobal(Run obj)
{
isInGame = false;
lastReceivedItemindex = 0;
Disconnect();
}
public void Disconnect()
{
if (session != null && session.Socket.Connected)
{
ArchipelagoConnectButtonController.ChangeButtonWhenDisconnected();
session.Socket.DisconnectAsync();
}
}
private void GameEndReportPanelController_Awake(orig_Awake orig, GameEndReportPanelController self)
{
//IL_0060: 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_0150: 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_026d: Unknown result type (might be due to invalid IL or missing references)
//IL_027f: Unknown result type (might be due to invalid IL or missing references)
//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
//IL_01d6: Expected O, but got Unknown
//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
//IL_02f3: Expected O, but got Unknown
//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0201: Unknown result type (might be due to invalid IL or missing references)
//IL_0207: Expected O, but got Unknown
//IL_0319: Unknown result type (might be due to invalid IL or missing references)
//IL_031e: Unknown result type (might be due to invalid IL or missing references)
//IL_0324: Expected O, but got Unknown
if (isEndingAcceptable && (Object)(object)ReleasePromptPanel == (Object)null)
{
if ((Object)(object)genericMenuButton != (Object)null)
{
GameObject gameObject = ((Component)genericMenuButton.transform.Find("HoverOutline")).gameObject;
}
else
{
GameObject gameObject = null;
}
string text = Convert.ToString(session.RoomState.ReleasePermissions);
string text2 = Convert.ToString(session.RoomState.CollectPermissions);
bool flag = text == "Goal" || text == "Enabled";
bool flag2 = text2 == "Goal" || text2 == "Enabled";
Log.LogDebug("can release " + text + " can collect " + text2);
Log.LogDebug($"release? {flag} collect? {flag2}");
Transform val = ((Component)self).transform.Find("SafeArea (JUICED)/BodyArea");
if (flag)
{
GameObject val2 = Object.Instantiate<GameObject>(ReleasePanel);
val2.transform.SetParent(((Component)val).transform, false);
val2.transform.localPosition = new Vector3(0f, 0f, 0f);
val2.transform.localScale = Vector3.one;
GameObject gameObject2 = ((Component)((Component)self).transform.Find("SafeArea (JUICED)/BodyArea/ReleasePrompt(Clone)/Panel/Release/")).gameObject;
gameObject2.AddComponent<HGButton>();
GameObject gameObject3 = ((Component)((Component)self).transform.Find("SafeArea (JUICED)/BodyArea/ReleasePrompt(Clone)/Panel/Cancel/")).gameObject;
gameObject3.AddComponent<HGButton>();
ButtonClickedEvent onClick = ((Button)gameObject2.GetComponent<HGButton>()).onClick;
object obj = <>c.<>9__86_0;
if (obj == null)
{
UnityAction val3 = delegate
{
OnReleaseClick(prompt: true);
};
<>c.<>9__86_0 = val3;
obj = (object)val3;
}
((UnityEvent)onClick).AddListener((UnityAction)obj);
ButtonClickedEvent onClick2 = ((Button)gameObject3.GetComponent<HGButton>()).onClick;
object obj2 = <>c.<>9__86_1;
if (obj2 == null)
{
UnityAction val4 = delegate
{
OnReleaseClick(prompt: false);
};
<>c.<>9__86_1 = val4;
obj2 = (object)val4;
}
((UnityEvent)onClick2).AddListener((UnityAction)obj2);
ReleasePromptPanel = ((Component)((Component)self).transform.Find("SafeArea (JUICED)/BodyArea/ReleasePrompt(Clone)")).gameObject;
}
if (flag2)
{
GameObject val5 = Object.Instantiate<GameObject>(CollectPanel);
val5.transform.SetParent(((Component)val).transform, false);
val5.transform.localPosition = new Vector3(0f, 0f, 0f);
val5.transform.localScale = Vector3.one;
GameObject gameObject4 = ((Component)((Component)self).transform.Find("SafeArea (JUICED)/BodyArea/CollectPrompt(Clone)/Panel/Collect/")).gameObject;
gameObject4.AddComponent<HGButton>();
GameObject gameObject5 = ((Component)((Component)self).transform.Find("SafeArea (JUICED)/BodyArea/CollectPrompt(Clone)/Panel/Cancel/")).gameObject;
gameObject5.AddComponent<HGButton>();
ButtonClickedEvent onClick3 = ((Button)gameObject4.GetComponent<HGButton>()).onClick;
object obj3 = <>c.<>9__86_2;
if (obj3 == null)
{
UnityAction val6 = delegate
{
OnCollectClick(prompt: true);
};
<>c.<>9__86_2 = val6;
obj3 = (object)val6;
}
((UnityEvent)onClick3).AddListener((UnityAction)obj3);
ButtonClickedEvent onClick4 = ((Button)gameObject5.GetComponent<HGButton>()).onClick;
object obj4 = <>c.<>9__86_3;
if (obj4 == null)
{
UnityAction val7 = delegate
{
OnCollectClick(prompt: false);
};
<>c.<>9__86_3 = val7;
obj4 = (object)val7;
}
((UnityEvent)onClick4).AddListener((UnityAction)obj4);
CollectPromptPanel = ((Component)((Component)self).transform.Find("SafeArea (JUICED)/BodyArea/CollectPrompt(Clone)")).gameObject;
CollectPromptPanel.SetActive(false);
}
if (flag2 && !flag)
{
CollectPromptPanel.SetActive(true);
}
}
orig.Invoke(self);
}
private void WillRelease(bool prompt)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
SayPacket val = new SayPacket();
if (prompt && isEndingAcceptable)
{
Log.LogDebug($"Releasing the rest of the items {isEndingAcceptable}");
val.Text = "!release";
session.Socket.SendPacketAsync((ArchipelagoPacketBase)(object)val);
}
ReleasePromptPanel.SetActive(false);
if ((Object)(object)CollectPromptPanel != (Object)null)
{
CollectPromptPanel.SetActive(true);
}
}
private void WillCollect(bool prompt)
{
//IL_0001: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Expected O, but got Unknown
SayPacket val = new SayPacket();
if (prompt && isEndingAcceptable)
{
Log.LogDebug($"Collect the rest of the items {isEndingAcceptable}");
val.Text = "!collect";
session.Socket.SendPacketAsync((ArchipelagoPacketBase)(object)val);
}
GameObject collectPromptPanel = CollectPromptPanel;
if (collectPromptPanel != null)
{
collectPromptPanel.SetActive(false);
}
}
}
public class ArchipelagoItemLogicController : IDisposable
{
public delegate void ItemDropProcessedHandler(int pickedUpCount);
private Random rnd = new Random();
private bool finishedAllChecks = false;
private ArchipelagoSession session;
private Queue<KeyValuePair<long, string>> itemReceivedQueue = new Queue<KeyValuePair<long, string>>();
private Queue<KeyValuePair<long, string>> environmentReceivedQueue = new Queue<KeyValuePair<long, string>>();
private Queue<KeyValuePair<long, string>> fillerReceivedQueue = new Queue<KeyValuePair<long, string>>();
private Queue<KeyValuePair<long, string>> trapReceivedQueue = new Queue<KeyValuePair<long, string>>();
private Queue<KeyValuePair<long, string>> stageReceivedQueue = new Queue<KeyValuePair<long, string>>();
private const long environmentRangeLower = 37700L;
private const long environmentRangeUpper = 37999L;
private const long fillerRangeLower = 37300L;
private const long fillerRangeUpper = 37399L;
private const long trapRangeLower = 37400L;
private const long trapRangeUpper = 37499L;
private const long stageRangeLower = 37500L;
private const long stageRangeUpper = 37599L;
private bool spawnedMonster = false;
private bool monsterShrineRecently = false;
private bool teleportedRecently = false;
private bool exitedPod = false;
private UniquePickup[] skippedItems;
private GameObject smokescreenPrefab;
private CombatDirector combatDirector;
public int PickedUpItemCount { get; set; }
public int ItemPickupStep { get; set; }
public long ItemStartId { get; private set; }
public int CurrentChecks { get; set; }
public int TotalChecks { get; set; }
internal StageBlockerHandler Stageblockerhandler { get; set; }
public long[] ChecksTogether { get; set; }
public long[] MissingChecks { get; set; }
private bool IsInGame => (RoR2Application.isInSinglePlayer || RoR2Application.isInMultiPlayer) && (Object)(object)Run.instance != (Object)null && exitedPod;
public event ItemDropProcessedHandler OnItemDropProcessed;
public ArchipelagoItemLogicController(ArchipelagoSession session)
{
//IL_0097: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Expected O, but got Unknown
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Expected O, but got Unknown
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Expected O, but got Unknown
//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
//IL_00e3: Expected O, but got Unknown
//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
//IL_00f5: Expected O, but got Unknown
//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Expected O, but got Unknown
//IL_0119: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_015b: Unknown result type (might be due to invalid IL or missing references)
//IL_0160: Unknown result type (might be due to invalid IL or missing references)
//IL_0165: Unknown result type (might be due to invalid IL or missing references)
//IL_016a: Unknown result type (might be due to invalid IL or missing references)
//IL_0176: Unknown result type (might be due to invalid IL or missing references)
//IL_017b: Unknown result type (might be due to invalid IL or missing references)
//IL_0180: Unknown result type (might be due to invalid IL or missing references)
//IL_0185: Unknown result type (might be due to invalid IL or missing references)
//IL_0191: Unknown result type (might be due to invalid IL or missing references)
//IL_0196: Unknown result type (might be due to invalid IL or missing references)
//IL_019b: Unknown result type (might be due to invalid IL or missing references)
//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
//IL_01e7: Unknown result type (might be due to invalid IL or missing references)
//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
//IL_0202: Unknown result type (might be due to invalid IL or missing references)
//IL_0207: Unknown result type (might be due to invalid IL or missing references)
//IL_020c: Unknown result type (might be due to invalid IL or missing references)
//IL_0218: Unknown result type (might be due to invalid IL or missing references)
//IL_021d: Unknown result type (might be due to invalid IL or missing references)
//IL_0222: Unknown result type (might be due to invalid IL or missing references)
//IL_0227: Unknown result type (might be due to invalid IL or missing references)
//IL_0233: Unknown result type (might be due to invalid IL or missing references)
//IL_0238: Unknown result type (might be due to invalid IL or missing references)
//IL_023d: Unknown result type (might be due to invalid IL or missing references)
//IL_0242: Unknown result type (might be due to invalid IL or missing references)
//IL_024f: Unknown result type (might be due to invalid IL or missing references)
//IL_0254: Unknown result type (might be due to invalid IL or missing references)
//IL_0259: Unknown result type (might be due to invalid IL or missing references)
//IL_025e: Unknown result type (might be due to invalid IL or missing references)
//IL_026b: Unknown result type (might be due to invalid IL or missing references)
//IL_0270: Unknown result type (might be due to invalid IL or missing references)
//IL_0275: Unknown result type (might be due to invalid IL or missing references)
//IL_027a: Unknown result type (might be due to invalid IL or missing references)
//IL_0287: Unknown result type (might be due to invalid IL or missing references)
//IL_028c: Unknown result type (might be due to invalid IL or missing references)
//IL_0291: Unknown result type (might be due to invalid IL or missing references)
//IL_0296: Unknown result type (might be due to invalid IL or missing references)
//IL_02a3: Unknown result type (might be due to invalid IL or missing references)
//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
//IL_02c9: Unknown result type (might be due to invalid IL or missing references)
//IL_02ce: Unknown result type (might be due to invalid IL or missing references)
//IL_02db: Unknown result type (might be due to invalid IL or missing references)
//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
//IL_02e5: Unknown result type (might be due to invalid IL or missing references)
//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0301: Unknown result type (might be due to invalid IL or missing references)
//IL_0306: Unknown result type (might be due to invalid IL or missing references)
//IL_0313: Unknown result type (might be due to invalid IL or missing references)
//IL_0318: Unknown result type (might be due to invalid IL or missing references)
//IL_031d: Unknown result type (might be due to invalid IL or missing references)
//IL_0322: Unknown result type (might be due to invalid IL or missing references)
//IL_032f: Unknown result type (might be due to invalid IL or missing references)
//IL_0334: Unknown result type (might be due to invalid IL or missing references)
//IL_0339: Unknown result type (might be due to invalid IL or missing references)
//IL_033e: Unknown result type (might be due to invalid IL or missing references)
//IL_034b: Unknown result type (might be due to invalid IL or missing references)
//IL_0350: Unknown result type (might be due to invalid IL or missing references)
//IL_0355: Unknown result type (might be due to invalid IL or missing references)
//IL_035a: Unknown result type (might be due to invalid IL or missing references)
//IL_0367: Unknown result type (might be due to invalid IL or missing references)
//IL_036c: Unknown result type (might be due to invalid IL or missing references)
//IL_0371: Unknown result type (might be due to invalid IL or missing references)
//IL_0376: Unknown result type (might be due to invalid IL or missing references)
//IL_0383: Unknown result type (might be due to invalid IL or missing references)
//IL_0388: Unknown result type (might be due to invalid IL or missing references)
//IL_038d: Unknown result type (might be due to invalid IL or missing references)
//IL_0392: Unknown result type (might be due to invalid IL or missing references)
//IL_039f: Unknown result type (might be due to invalid IL or missing references)
//IL_03a4: Unknown result type (might be due to invalid IL or missing references)
//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
//IL_03ae: Unknown result type (might be due to invalid IL or missing references)
//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
//IL_03d7: Unknown result type (might be due to invalid IL or missing references)
//IL_03dc: Unknown result type (might be due to invalid IL or missing references)
//IL_03e1: Unknown result type (might be due to invalid IL or missing references)
//IL_03e6: Unknown result type (might be due to invalid IL or missing references)
this.session = session;
ItemStartId = session.Locations.GetLocationIdFromName("Risk of Rain 2", "ItemPickup1");
RoR2Application.Update += new hook_Update(RoR2Application_Update);
SceneDirector.Start += new hook_Start(SceneDirector_Start);
session.Socket.PacketReceived += new PacketReceivedHandler(Session_PacketReceived);
session.Items.ItemReceived += new ItemReceivedHandler(Items_ItemReceived);
CombatDirector.Awake += new hook_Awake(CombatDirector_Awake);
SurvivorPodController.OnPassengerExit += new hook_OnPassengerExit(SurvivorPodController_OnPassengerExit);
Log.LogDebug("Okay finished hooking.");
smokescreenPrefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Junk/Bandit/SmokescreenEffect.prefab").WaitForCompletion();
Log.LogDebug("Okay, finished getting prefab.");
Log.LogDebug($"smokescreen {smokescreenPrefab}");
skippedItems = (UniquePickup[])(object)new UniquePickup[24]
{
new UniquePickup(PickupCatalog.FindPickupIndex(Equipment.AffixBlue.equipmentIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Equipment.AffixHaunted.equipmentIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Equipment.AffixLunar.equipmentIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Equipment.AffixPoison.equipmentIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Equipment.AffixRed.equipmentIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Equipment.AffixWhite.equipmentIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(MiscPickups.LunarCoin.miscPickupIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Items.ArtifactKey.itemIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.Bomb.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.Command.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.EliteOnly.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.Enigma.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.FriendlyFire.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.Glass.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.MixEnemy.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.MonsterTeamGainsItems.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.RandomSurvivorOnRespawn.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.Sacrifice.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.ShadowClone.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.SingleMonsterType.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.Swarms.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.TeamDeath.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.WeakAssKnees.artifactIndex)),
new UniquePickup(PickupCatalog.FindPickupIndex(Artifacts.WispOnDeath.artifactIndex))
};
Log.LogDebug("Ok, finished browsing catalog.");
}
private void SceneDirector_Start(orig_Start orig, SceneDirector self)
{
orig.Invoke(self);
exitedPod = true;
ArchipelagoClient.isInGame = true;
}
private void SurvivorPodController_OnPassengerExit(orig_OnPassengerExit orig, SurvivorPodController self, GameObject passenger)
{
orig.Invoke(self, passenger);
Thread thread = new Thread((ThreadStart)delegate
{
TeleportedRecently();
});
thread.Start();
teleportedRecently = true;
exitedPod = true;
ArchipelagoClient.isInGame = true;
}
private void CombatDirector_Awake(orig_Awake orig, CombatDirector self)
{
orig.Invoke(self);
combatDirector = self;
}
private void Items_ItemReceived(ReceivedItemsHelper helper)
{
ItemInfo val = helper.DequeueItem();
if (ArchipelagoClient.lastReceivedItemindex < helper.AllItemsReceived.Count)
{
EnqueueItem(val.ItemId);
ArchipelagoClient.lastReceivedItemindex = helper.AllItemsReceived.Count;
}
else if (37700 <= val.ItemId && val.ItemId <= 37999)
{
EnqueueItem(val.ItemId);
}
}
private void Check_Locations(ReadOnlyCollection<long> item)
{
long[] array = new long[item.Count];
item.CopyTo(array, 0);
if (MissingChecks != null)
{
for (int i = 0; i < array.Length; i++)
{
List<long> list = new List<long>(MissingChecks);
int index = Array.IndexOf(MissingChecks, array[i]);
list.RemoveAt(index);
MissingChecks = list.ToArray();
}
Update_MissingChecks();
}
}
private void Update_MissingChecks()
{
if (MissingChecks.Count() > 0 && ChecksTogether != null)
{
int num = Array.IndexOf(ChecksTogether, MissingChecks[0]);
Log.LogInfo($"Last item collected is {num}/{TotalChecks} next missing id is {MissingChecks[0]}");
CurrentChecks = num;
PickedUpItemCount = num * ItemPickupStep;
ArchipelagoTotalChecksObjectiveController.CurrentChecks = CurrentChecks;
}
}
private void Session_PacketReceived(ArchipelagoPacketBase packet)
{
//IL_0002: 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)
//IL_0008: 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_000a: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Invalid comparison between Unknown and I4
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00b8: Expected O, but got Unknown
//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
//IL_00ca: Expected O, but got Unknown
//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
//IL_00e7: Expected O, but got Unknown
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_0073: Expected O, but got Unknown
//IL_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0085: Expected O, but got Unknown
//IL_0098: Unknown result type (might be due to invalid IL or missing references)
//IL_00a2: Expected O, but got Unknown
ArchipelagoPacketType packetType = packet.PacketType;
ArchipelagoPacketType val = packetType;
if ((int)val != 2)
{
return;
}
ConnectedPacket val2 = (ConnectedPacket)(object)((packet is ConnectedPacket) ? packet : null);
object value;
bool flag = !val2.SlotData.TryGetValue("goal", out value) || !Convert.ToBoolean(value);
Log.LogDebug($"Detected classic_mode from ArchipelagoItemLogicController? {flag}");
if (flag)
{
PickupDropletController.CreatePickupDroplet_CreatePickupInfo_Vector3_Vector3 += new hook_CreatePickupDroplet_CreatePickupInfo_Vector3_Vector3(PickupDropletController_CreatePickupDroplet_CreatePickupInfo);
ChestBehavior.ItemDrop += new hook_ItemDrop(ChestBehavior_ItemDrop);
session.Locations.CheckedLocationsUpdated += new CheckedLocationsUpdatedHandler(Check_Locations);
}
else
{
PickupDropletController.CreatePickupDroplet_CreatePickupInfo_Vector3_Vector3 -= new hook_CreatePickupDroplet_CreatePickupInfo_Vector3_Vector3(PickupDropletController_CreatePickupDroplet_CreatePickupInfo);
ChestBehavior.ItemDrop -= new hook_ItemDrop(ChestBehavior_ItemDrop);
session.Locations.CheckedLocationsUpdated -= new CheckedLocationsUpdatedHandler(Check_Locations);
}
ItemPickupStep = Convert.ToInt32(val2.SlotData["itemPickupStep"]) + 1;
TotalChecks = val2.LocationsChecked.Count() + val2.MissingChecks.Count();
ChecksTogether = val2.LocationsChecked.Concat(val2.MissingChecks).ToArray();
ChecksTogether = ChecksTogether.OrderBy((long n) => n).ToArray();
MissingChecks = val2.MissingChecks;
Log.LogDebug($"Missing Checks {val2.MissingChecks.Count()} totalChecks {TotalChecks} Locations Checked {val2.LocationsChecked.Count()}");
if (ItemStartId == -1)
{
ItemStartId = session.Locations.GetLocationIdFromName("Risk of Rain 2", "ItemPickup1");
if (ItemStartId == -1)
{
ItemStartId = 38000L;
}
}
if (val2.MissingChecks.Count() == 0)
{
CurrentChecks = TotalChecks;
finishedAllChecks = true;
}
else if (flag)
{
int num = Array.IndexOf(ChecksTogether, val2.MissingChecks[0]);
Log.LogInfo($"Missing index is {num} first missing id is {val2.MissingChecks[0]}");
ItemStartId = ChecksTogether[0];
Log.LogInfo($"ItemStartId {ItemStartId}");
CurrentChecks = num;
}
else
{
CurrentChecks = ChecksTogether.Length - val2.MissingChecks.Count();
}
ArchipelagoTotalChecksObjectiveController.CurrentChecks = CurrentChecks;
ArchipelagoTotalChecksObjectiveController.TotalChecks = TotalChecks;
NetMessageExtensions.Send((INetMessage)(object)new SyncTotalCheckProgress(CurrentChecks, TotalChecks), (NetworkDestination)1);
PickedUpItemCount = CurrentChecks * ItemPickupStep;
}
public void EnqueueItem(long itemId)
{
string itemName = session.Items.GetItemName(itemId, (string)null);
if (37700 <= itemId && itemId <= 37999)
{
environmentReceivedQueue.Enqueue(new KeyValuePair<long, string>(itemId, itemName));
}
else if (37300 <= itemId && itemId <= 37399)
{
fillerReceivedQueue.Enqueue(new KeyValuePair<long, string>(itemId, itemName));
}
else if (37400 <= itemId && itemId <= 37499)
{
trapReceivedQueue.Enqueue(new KeyValuePair<long, string>(itemId, itemName));
}
else if (37500 <= itemId && itemId <= 37599)
{
stageReceivedQueue.Enqueue(new KeyValuePair<long, string>(itemId, itemName));
}
else
{
itemReceivedQueue.Enqueue(new KeyValuePair<long, string>(itemId, itemName));
}
}
public void Dispose()
{
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Expected O, but got Unknown
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_0024: Expected O, but got Unknown
//IL_002c: Unknown result type (might be due to invalid IL or missing references)
//IL_0036: Expected O, but got Unknown
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0061: Expected O, but got Unknown
//IL_0074: Unknown result type (might be due to invalid IL or missing references)
//IL_007e: Expected O, but got Unknown
PickupDropletController.CreatePickupDroplet_CreatePickupInfo_Vector3_Vector3 -= new hook_CreatePickupDroplet_CreatePickupInfo_Vector3_Vector3(PickupDropletController_CreatePickupDroplet_CreatePickupInfo);
ChestBehavior.ItemDrop -= new hook_ItemDrop(ChestBehavior_ItemDrop);
RoR2Application.Update -= new hook_Update(RoR2Application_Update);
if (session != null)
{
session.Socket.PacketReceived -= new PacketReceivedHandler(Session_PacketReceived);
session.Items.ItemReceived -= new ItemReceivedHandler(Items_ItemReceived);
session = null;
}
}
public void Precollect()
{
while (environmentReceivedQueue.Any())
{
Log.LogDebug("Precollecting environment...");
HandleReceivedEnvironmentQueueItem();
}
}
private void RoR2Application_Update(orig_Update orig, RoR2Application self)
{
if (environmentReceivedQueue.Any())
{
HandleReceivedEnvironmentQueueItem();
}
if (stageReceivedQueue.Any())
{
HandleReceivedStageQueueItem();
}
if (IsInGame)
{
if (itemReceivedQueue.Any())
{
HandleReceivedItemQueueItem();
}
if (fillerReceivedQueue.Any())
{
HandleReceivedFillerQueueItem();
}
if (trapReceivedQueue.Any())
{
HandleReceivedTrapQueueItem();
}
}
orig.Invoke(self);
}
private void HandleReceivedEnvironmentQueueItem()
{
//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
KeyValuePair<long, string> keyValuePair = environmentReceivedQueue.Dequeue();
long num = keyValuePair.Key;
string value = keyValuePair.Value;
if (num == 37746 && value == "The Planetarium")
{
num = 37745L;
Log.LogDebug("Changing id to 45");
}
else if (num == 37745 && value == "Void Locus")
{
num = 37746L;
Log.LogDebug("Changing id to 46");
}
Log.LogDebug($"Handling environment with itemid {num} with name {value}");
Stageblockerhandler?.UnBlock((int)(num - 37700));
if (IsInGame)
{
ChatMessage.SendColored("Received " + value + "!", Color.magenta);
}
}
private void HandleReceivedFillerQueueItem()
{
KeyValuePair<long, string> keyValuePair = fillerReceivedQueue.Dequeue();
long key = keyValuePair.Key;
string value = keyValuePair.Value;
long num = key;
long num2 = num;
long num3 = num2 - 37301;
if ((ulong)num3 <= 2uL)
{
switch (num3)
{
case 0L:
GiveMoneyToPlayers();
break;
case 1L:
GiveLunarCoinToPlayers();
break;
case 2L:
GiveExperienceToPlayers();
break;
}
}
}
private void HandleReceivedTrapQueueItem()
{
KeyValuePair<long, string> keyValuePair = trapReceivedQueue.Dequeue();
long key = keyValuePair.Key;
string value = keyValuePair.Value;
long num = key;
long num2 = num;
long num3 = num2 - 37401;
if ((ulong)num3 <= 3uL)
{
switch (num3)
{
case 0L:
MountainShrineTrap();
break;
case 1L:
TimeWarpTrap();
break;
case 2L:
SpawnMonstersTrap();
break;
case 3L:
TeleportPlayer();
break;
}
}
}
private void HandleReceivedStageQueueItem()
{
//IL_0078: Unknown result type (might be due to invalid IL or missing references)
//IL_004c: Unknown result type (might be due to invalid IL or missing references)
KeyValuePair<long, string> keyValuePair = stageReceivedQueue.Dequeue();
long key = keyValuePair.Key;
string value = keyValuePair.Value;
if (key == 37505)
{
StageBlockerHandler.amountOfStages++;
ChatMessage.SendColored($"Received {value} #{StageBlockerHandler.amountOfStages}!", Color.magenta);
}
else
{
StageBlockerHandler.stageUnlocks[value] = true;
ChatMessage.SendColored("Received " + value + "!", Color.magenta);
}
}
private void HandleReceivedItemQueueItem()
{
//IL_059b: Unknown result type (might be due to invalid IL or missing references)
//IL_05a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
//IL_0107: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_010f: Unknown result type (might be due to invalid IL or missing references)
//IL_015a: Unknown result type (might be due to invalid IL or missing references)
//IL_015f: 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_01ad: Unknown result type (might be due to invalid IL or missing references)
//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
//IL_0200: Unknown result type (might be due to invalid IL or missing references)
//IL_0205: Unknown result type (might be due to invalid IL or missing references)
//IL_0207: Unknown result type (might be due to invalid IL or missing references)
//IL_0212: Unknown result type (might be due to invalid IL or missing references)
//IL_0218: Invalid comparison between Unknown and I4
//IL_0293: Unknown result type (might be due to invalid IL or missing references)
//IL_0298: Unknown result type (might be due to invalid IL or missing references)
//IL_029b: Unknown result type (might be due to invalid IL or missing references)
//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
//IL_0331: Unknown result type (might be due to invalid IL or missing references)
//IL_0336: Unknown result type (might be due to invalid IL or missing references)
//IL_0380: Unknown result type (might be due to invalid IL or missing references)
//IL_0385: Unknown result type (might be due to invalid IL or missing references)
//IL_03cf: Unknown result type (might be due to invalid IL or missing references)
//IL_03d4: Unknown result type (might be due to invalid IL or missing references)
//IL_0430: Unknown result type (might be due to invalid IL or missing references)
//IL_0500: Unknown result type (might be due to invalid IL or missing references)
//IL_0505: Unknown result type (might be due to invalid IL or missing references)
//IL_054f: Unknown result type (might be due to invalid IL or missing references)
//IL_0554: Unknown result type (might be due to invalid IL or missing references)
//IL_0234: Unknown result type (might be due to invalid IL or missing references)
//IL_023a: Invalid comparison between Unknown and I4
//IL_0225: Unknown result type (might be due to invalid IL or missing references)
//IL_0450: Unknown result type (might be due to invalid IL or missing references)
//IL_0455: Unknown result type (might be due to invalid IL or missing references)
//IL_0247: Unknown result type (might be due to invalid IL or missing references)
//IL_0474: Unknown result type (might be due to invalid IL or missing references)
//IL_0479: Unknown result type (might be due to invalid IL or missing references)
//IL_04b6: Unknown result type (might be due to invalid IL or missing references)
//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
//IL_04b2: Unknown result type (might be due to invalid IL or missing references)
//IL_0498: Unknown result type (might be due to invalid IL or missing references)
//IL_049d: Unknown result type (might be due to invalid IL or missing references)
KeyValuePair<long, string> keyValuePair = itemReceivedQueue.Dequeue();
long key = keyValuePair.Key;
string value = keyValuePair.Value;
Log.LogDebug($"Handling item with itemid {key} with name {value}");
long num = key;
long num2 = num;
long num3 = num2 - 37001;
if ((ulong)num3 > 13uL)
{
return;
}
switch (num3)
{
case 1L:
{
foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
{
PickupIndex pickupIndex5 = Run.instance.availableTier1DropList.Choice();
GiveItemToPlayers(pickupIndex5, instance);
}
break;
}
case 2L:
{
foreach (PlayerCharacterMasterController instance2 in PlayerCharacterMasterController.instances)
{
PickupIndex pickupIndex4 = Run.instance.availableTier2DropList.Choice();
GiveItemToPlayers(pickupIndex4, instance2);
}
break;
}
case 3L:
{
foreach (PlayerCharacterMasterController instance3 in PlayerCharacterMasterController.instances)
{
PickupIndex pickupIndex3 = Run.instance.availableTier3DropList.Choice();
GiveItemToPlayers(pickupIndex3, instance3);
}
break;
}
case 4L:
{
foreach (PlayerCharacterMasterController instance4 in PlayerCharacterMasterController.instances)
{
PickupIndex pickupIndex2 = Run.instance.availableBossDropList.Choice();
GiveItemToPlayers(pickupIndex2, instance4);
}
break;
}
case 5L:
{
foreach (PlayerCharacterMasterController instance5 in PlayerCharacterMasterController.instances)
{
PickupIndex val2 = Run.instance.availableLunarCombinedDropList.Choice();
PickupDef pickupDef = PickupCatalog.GetPickupDef(val2);
if ((int)pickupDef.itemIndex != -1)
{
GiveItemToPlayers(val2, instance5);
}
else if ((int)pickupDef.equipmentIndex != -1)
{
GiveEquipmentToPlayers(val2, instance5);
}
}
break;
}
case 6L:
{
foreach (PlayerCharacterMasterController instance6 in PlayerCharacterMasterController.instances)
{
PickupIndex pickupIndex = Run.instance.availableEquipmentDropList.Choice();
GiveEquipmentToPlayers(pickupIndex, instance6);
}
break;
}
case 7L:
{
foreach (PlayerCharacterMasterController instance7 in PlayerCharacterMasterController.instances)
{
GiveItemToPlayers(PickupCatalog.FindPickupIndex(Items.ScrapWhite.itemIndex), instance7);
}
break;
}
case 8L:
{
foreach (PlayerCharacterMasterController instance8 in PlayerCharacterMasterController.instances)
{
GiveItemToPlayers(PickupCatalog.FindPickupIndex(Items.ScrapGreen.itemIndex), instance8);
}
break;
}
case 9L:
{
foreach (PlayerCharacterMasterController instance9 in PlayerCharacterMasterController.instances)
{
GiveItemToPlayers(PickupCatalog.FindPickupIndex(Items.ScrapRed.itemIndex), instance9);
}
break;
}
case 10L:
{
foreach (PlayerCharacterMasterController instance10 in PlayerCharacterMasterController.instances)
{
GiveItemToPlayers(PickupCatalog.FindPickupIndex(Items.ScrapYellow.itemIndex), instance10);
}
break;
}
case 11L:
{
foreach (PlayerCharacterMasterController instance11 in PlayerCharacterMasterController.instances)
{
int maxValue = 125;
int num4 = rnd.Next(maxValue);
PickupIndex val = default(PickupIndex);
val = ((num4 > 70) ? ((num4 > 110) ? ((num4 > 120) ? Run.instance.availableVoidBossDropList.Choice() : Run.instance.availableVoidTier3DropList.Choice()) : Run.instance.availableVoidTier2DropList.Choice()) : Run.instance.availableVoidTier1DropList.Choice());
GiveItemToPlayers(val, instance11);
}
break;
}
case 12L:
{
foreach (PlayerCharacterMasterController instance12 in PlayerCharacterMasterController.instances)
{
GiveItemToPlayers(PickupCatalog.FindPickupIndex(Items.LunarTrinket.itemIndex), instance12);
}
break;
}
case 13L:
{
foreach (PlayerCharacterMasterController instance13 in PlayerCharacterMasterController.instances)
{
GiveEquipmentToPlayers(PickupCatalog.FindPickupIndex(Equipment.Scanner.equipmentIndex), instance13);
}
break;
}
case 0L:
{
foreach (PlayerCharacterMasterController instance14 in PlayerCharacterMasterController.instances)
{
GiveItemToPlayers(PickupCatalog.FindPickupIndex(Items.ExtraLife.itemIndex), instance14);
}
break;
}
}
}
private void GiveEquipmentToPlayers(PickupIndex pickupIndex, PlayerCharacterMasterController player)
{
//IL_0014: 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_001c: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_004f: Unknown result type (might be due to invalid IL or missing references)
//IL_0057: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//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)
//IL_007c: 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_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6->IL00a6: Incompatible stack types: O vs I4
//IL_00a1->IL00a6: Incompatible stack types: I4 vs O
//IL_00a1->IL00a6: Incompatible stack types: O vs I4
Inventory inventory = player.master.inventory;
EquipmentState equipment = inventory.GetEquipment((uint)inventory.activeEquipmentSlot);
if (!((EquipmentState)(ref equipment)).Equals(EquipmentState.empty))
{
GameObject bodyObject = player.master.GetBodyObject();
if ((Object)(object)bodyObject == (Object)null)
{
return;
}
CreatePickupInfo val = default(CreatePickupInfo);
((CreatePickupInfo)(ref val)).pickupIndex = PickupCatalog.FindPickupIndex(equipment.equipmentIndex);
val.position = bodyObject.transform.position;
val.rotation = Quaternion.identity;
CreatePickupInfo val2 = val;
GenericPickupController.CreatePickup(ref val2);
}
object obj = inventory;
PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
int num;
if (pickupDef != null)
{
obj = pickupDef.equipmentIndex;
num = (int)obj;
}
else
{
num = -1;
obj = num;
num = (int)obj;
}
((Inventory)num).SetEquipmentIndex((EquipmentIndex)obj);
if (!NetworkServer.active)
{
CharacterMasterNotificationQueue.PushPickupNotification(player.master, pickupIndex);
}
else
{
DisplayPickupNotification(pickupIndex, player);
}
}
private void GiveItemToPlayers(PickupIndex pickupIndex, PlayerCharacterMasterController player)
{
//IL_000e: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: 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_0020->IL0020: Incompatible stack types: O vs I4
//IL_001b->IL0020: Incompatible stack types: I4 vs O
//IL_001b->IL0020: Incompatible stack types: O vs I4
Inventory inventory = player.master.inventory;
object obj = inventory;
PickupDef pickupDef = PickupCatalog.GetPickupDef(pickupIndex);
int num;
if (pickupDef != null)
{
obj = pickupDef.itemIndex;
num = (int)obj;
}
else
{
num = -1;
obj = num;
num = (int)obj;
}
((Inventory)num).GiveItemPermanent((ItemIndex)obj, 1);
if (!NetworkServer.active)
{
CharacterMasterNotificationQueue.PushPickupNotification(player.master, pickupIndex);
}
else
{
DisplayPickupNotification(pickupIndex, player);
}
}
private void GiveMoneyToPlayers()
{
//IL_0058: Unknown result type (might be due to invalid IL or missing references)
//IL_005d: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: 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_0090: Unknown result type (might be due to invalid IL or missing references)
//IL_0091: Unknown result type (might be due to invalid IL or missing references)
//IL_0096: 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_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00ac: Expected O, but got Unknown
foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
{
float difficultyCoefficient = Run.instance.difficultyCoefficient;
uint num = (uint)(100f * difficultyCoefficient);
Log.LogDebug($"Received {num}");
CharacterMaster master = instance.master;
master.money += num;
Chat.SendBroadcastChat((ChatMessageBase)new PlayerPickupChatMessage
{
subjectAsCharacterBody = instance.master.GetBody(),
baseToken = "PLAYER_PICKUP",
pickupToken = $"${num}!!!",
pickupColor = Color32.op_Implicit(Color.green),
pickupQuantity = 1u
});
}
}
private void GiveLunarCoinToPlayers()
{
//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_0040: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Expected O, but got Unknown
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
//IL_0069: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: Unknown result type (might be due to invalid IL or missing references)
//IL_0084: Unknown result type (might be due to invalid IL or missing references)
//IL_008f: Unknown result type (might be due to invalid IL or missing references)
//IL_00a1: Expected O, but got Unknown
//IL_009c: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Expected O, but got Unknown
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
//IL_00c2: 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)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
{
GameObject prefab = Addressables.LoadAssetAsync<GameObject>((object)"RoR2/Base/Common/GenericPickup.prefab").WaitForCompletion();
SpawnCard val = ScriptableObject.CreateInstance<SpawnCard>();
val.prefab = prefab;
Xoroshiro128Plus val2 = new Xoroshiro128Plus(RoR2Application.rng);
if ((Object)(object)DirectorCore.instance != (Object)null)
{
GameObject val3 = DirectorCore.instance.TrySpawnObject(new DirectorSpawnRequest(val, new DirectorPlacementRule
{
placementMode = (PlacementMode)0,
spawnOnTarget = instance.master.GetBody().transform,
minDistance = 1f,
maxDistance = 10f
}, val2));
Vector3 position = val3.transform.position;
val3.GetComponent<GenericPickupController>().pickupIndex = PickupCatalog.FindPickupIndex(MiscPickups.LunarCoin.miscPickupIndex);
Log.LogDebug($"coin position {position + new Vector3(0f, 10f, 0f)}");
NetworkServer.Spawn(val3);
}
}
}
private void GiveExperienceToPlayers()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: 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_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)
//IL_0057: 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)
//IL_0061: Unknown result type (might be due to invalid IL or missing references)
//IL_0066: Unknown result type (might be due to invalid IL or missing references)
//IL_0072: Expected O, but got Unknown
foreach (PlayerCharacterMasterController instance in PlayerCharacterMasterController.instances)
{
instance.master.GiveExperience(1000uL);
Chat.SendBroadcastChat((ChatMessageBase)new PlayerPickupChatMessage
{
subjectAsCharacterBody = instance.master.GetBody(),
baseToken = "PLAYER_PICKUP",
pickupToken = "1000 XP",
pickupColor = Color32.op_Implicit(Color.white),
pickupQuantity = 1u
});
}
}
private void MountainShrineTrap()
{
//IL_0014: Unknown result type (might be due to invalid IL or missing references)
if (!monsterShrineRecently)
{
ChatMessage.SendColored("<style=cShrine>The Mountain has invited you for a challenge..", Color.yellow);
TeleporterInteraction.instance.AddShrineStack();
monsterShrineRecently = true;
Thread thread = new Thread((ThreadStart)delegate
{
MountainShrineRecently();
});
thread.Start();
PlayShrineSound();
}
}
private void MountainShrineRecently()
{
Thread.Sleep(2000);
Log.LogDebug("You can get another mountain trap now.");
monsterShrineRecently = false;
}
private void PlayShrineSound()
{
//IL_0018: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0044: Expected O, but got Unknown
if (PlayerCharacterMasterController.instances != null)
{
EffectManager.SpawnEffect(LegacyResourcesAPI.Load<GameObject>("Prefabs/Effects/ShrineUseEffect"), new EffectData
{
origin = PlayerCharacterMasterController.instances[0].body.transform.position
}, true);
}
}
private void SpawnMonstersTrap()
{
//IL_009e: Unknown result type (might be due to invalid IL or missing references)
//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
if (!((Object)(object)combatDirector != (Object)null) || spawnedMonster)
{
return;
}
PlayerCharacterMasterController val = PlayerCharacterMasterController.instances[0];
if (!((Object)(object)val.master.GetBody() == (Object)null))
{
spawnedMonster = true;
Thread thread = new Thread((ThreadStart)delegate
{
SpawnedMonstersRecently();
});
thread.Start();
float difficultyCoefficient = Run.instance.difficultyCoefficient;
combatDirector.monsterCredit = 100f * difficultyCoefficient;
Log.LogDebug($"player position {val.master.GetBody().transform.localPosition} monster credit 100 * {difficultyCoefficient} = {100f * difficultyCoefficient}");
combatDirector.SpendAllCreditsOnMapSpawns(val.master.GetBody().transform);
ChatMessage.SendColored("Incoming Monsters!!", Color.red);
PlayShrineSound();
}
}
private void SpawnedMonstersRecently()
{
Thread.Sleep(2000);
Log.LogDebug("You can get another monster trap now.");
spawnedMonster = false;
}
private void TeleportPlayer()
{
//IL_0051: Unknown result type (might be due to invalid IL or missing references)
//IL_0058: Expected O, but got Unknown
//IL_0074: 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_007b: Unknown result type (might be due to invalid IL or missing references)
//IL_0087: Expected O, but got Unknown
//IL_0082: Unknown result type (might be due to invalid IL or missing references)
//IL_008c: Expected O, but got Unknown
//IL_0095: Unknown result type (might be due to invalid IL or missing references)
//IL_009a: 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)
//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
//IL_00c0: Expected O, but got Unknown
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00d1: 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)
//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_0136: Unknown result type (might be due to invalid IL or missing references)
//IL_013b: Unknown result type (might be due to invalid IL or missing references)
if (teleportedRecently)
{
return;
}
foreach (NetworkUser readOnlyLocalPlayers in NetworkUser.readOnlyLocalPlayersList)
{
if (Object.op_Implicit((Object)(object)readOnlyLocalPlayers))
{
SpawnCard val = ScriptableObject.CreateInstance<SpawnCard>();
val = LegacyResourcesAPI.Load<SpawnCard>("SpawnCards/InteractableSpawnCard/iscBarrel1");
Xoroshiro128Plus val2 = new Xoroshiro128Plus(RoR2Application.rng);
if ((Object)(object)DirectorCore.instance != (Object)null)
{
GameObject val3 = DirectorCore.instance.TrySpawnObject(new DirectorSpawnRequest(val, new DirectorPlacementRule
{
placementMode = (PlacementMode)4
}, val2));
Vector3 position = val3.transform.position;
DirectorPlacementRule val4 = new DirectorPlacementRule
{
placementMode = (PlacementMode)4,
minDistance = 5f,
maxDistance = 20f
};
Log.LogDebug($"directorPlacemnet {val4.targetPosition} card position {position + new Vector3(0f, 10f, 0f)} player position {((Component)readOnlyLocalPlayers.master).transform.position}");
CharacterBody body = readOnlyLocalPlayers.master.GetBody();
((Component)body).GetComponentInChildren<KinematicCharacterMotor>().SetPosition(position + new Vector3(0f, 10f, 0f), true);
NetMessageExtensions.Send((INetMessage)(object)new ArchipelagoTeleportClient(), (NetworkDestination)1);
val3.SetActive(false);
}
}
}
}
private void TeleportedRecently()
{
Thread.Sleep(2000);
Log.LogDebug("You can teleport again");
teleportedRecently = false;
}
private void TimeWarpTrap()
{
//IL_0025: Unknown result type (might be due to invalid IL or missing references)
float runStopwatch = Run.instance.GetRunStopwatch();
runStopwatch += 180f;
Run.instance.SetRunStopwatch(runStopwatch);
ChatMessage.SendColored("Monsters grow stronger with time!", Color.red);
TeamManager.instance.SetTeamLevel((TeamIndex)2, 1u);
}
private void DisplayPickupNotification(PickupIndex index, PlayerCharacterMasterController player)
{
//IL_000d: Unknown result type (might be due to invalid IL or missing references)
//IL_0015: Unknown result type (might be due to invalid IL or missing references)
//IL_001a: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Unknown result type (might be due to invalid IL or missing references)
//IL_001d: Invalid comparison between Unknown and I4
//IL_0045: Unknown result type (might be due to invalid IL or missing references)
//IL_004a: Unknown result type (might be due to invalid IL or missing references)
//IL_004b: Unknown result type (might be due to invalid IL or missing references)
//IL_004d: Invalid comparison between Unknown and I4
//IL_002a: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
//IL_0075: 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_0084: 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_009b: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
//IL_00af: Unknown result type (might be due to invalid IL or missing references)
//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
//IL_00c7: Expected O, but got Unknown
//IL_005a: 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_0072: Expected O, but got Unknown
CharacterMasterNotificationQueue notificationQueueForMaster = CharacterMasterNotificationQueue.GetNotificationQueueForMaster(player.master);
PickupDef pickupDef = PickupCatalog.GetPickupDef(index);
ItemIndex itemIndex = pickupDef.itemIndex;
if ((int)itemIndex != -1)
{
notificationQueueForMaster.PushNotification(new NotificationInfo((object)ItemCatalog.GetItemDef(itemIndex), (TransformationInfo)null, false, 0), 2f);
}
EquipmentIndex equipmentIndex = pickupDef.equipmentIndex;
if ((int)equipmentIndex != -1)
{
notificationQueueForMaster.PushNotification(new NotificationInfo((object)EquipmentCatalog.GetEquipmentDef(equipmentIndex), (TransformationInfo)null, false, 0), 2f);
}
Color baseColor = pickupDef.baseColor;
string nameToken = pickupDef.nameToken;
Chat.SendBroadcastChat((ChatMessageBase)new PlayerPickupChatMessage
{
subjectAsCharacterBody = player.master.GetBody(),
baseToken = "PLAYER_PICKUP",
pickupToken = nameToken,
pickupColor = Color32.op_Implicit(baseColor),
pickupQuantity = 1u
});
}
private void ChestBehavior_ItemDrop(orig_ItemDrop orig, ChestBehavior self)
{
bool flag = finishedAllChecks || HandleItemDrop();
if (this.OnItemDropProcessed != null)
{
this.OnItemDropProcessed(PickedUpItemCount);
}
if (flag)
{
orig.Invoke(self);
}
NetMessageExtensions.Send((INetMessage)(object)new SyncTotalCheckProgress(finishedAllChecks ? TotalChecks : CurrentChecks, TotalChecks), (NetworkDestination)1);
if (finishedAllChecks)
{
ArchipelagoTotalChecksObjectiveController.RemoveObjective();
NetMessageExtensions.Send((INetMessage)(object)new AllChecksComplete(), (NetworkDestination)1);
}
}
private void PickupDropletController_CreatePickupDroplet_CreatePickupInfo(orig_CreatePickupDroplet_CreatePickupInfo_Vector3_Vector3 orig, CreatePickupInfo pickupInfo, Vector3 position, Vector3 velocity)
{
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0023: 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_0025: Unknown result type (might be due to invalid IL or missing references)
//IL_006c: Unknown result type (might be due to invalid IL or missing references)
//IL_006d: Unknown result type (might be due to invalid IL or missing references)
//IL_006e: 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_008d: Unknown result type (might be due to invalid IL or missing references)
//IL_008e: Unknown result type (might be due to invalid IL or missing references)
//IL_009b: Expected O, but got Unknown
if (Array.IndexOf(skippedItems, pickupInfo._pickupState) >= 0)
{
orig.Invoke(pickupInfo, position, velocity);
return;
}
bool flag = finishedAllChecks || HandleItemDrop();
if (this.OnItemDropProcessed != null)
{
this.OnItemDropProcessed(PickedUpItemCount);
}
if (flag)
{
orig.Invoke(pickupInfo, position, velocity);
}
if (!flag)
{
EffectManager.SpawnEffect(smokescreenPrefab, new EffectData
{
origin = position
}, true);
}
NetMessageExtensions.Send((INetMessage)(object)new SyncTotalCheckProgress(finishedAllChecks ? TotalChecks : CurrentChecks, TotalChecks), (NetworkDestination)1);
if (finishedAllChecks)
{
ArchipelagoTotalChecksObjectiveController.RemoveObjective();
NetMessageExtensions.Send((INetMessage)(object)new AllChecksComplete(), (NetworkDestination)1);
}
}
private bool HandleItemDrop()
{
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a6: Expected O, but got Unknown
PickedUpItemCount++;
Log.LogDebug($"PickedUpItemCount + 1 {PickedUpItemCount} ItemPickupStep {ItemPickupStep}");
if (PickedUpItemCount % ItemPickupStep == 0)
{
CurrentChecks++;
string arg = $"ItemPickup{CurrentChecks}";
long num = ItemStartId + CurrentChecks - 1;
Log.LogDebug($"Sent out location {arg} (id: {num})");
LocationChecksPacket val = new LocationChecksPacket();
val.Locations = new List<long> { num }.ToArray();
session.Socket.SendPacketAsync((ArchipelagoPacketBase)(object)val);
if (CurrentChecks == TotalChecks)
{
ArchipelagoTotalChecksObjectiveController.CurrentChecks = ArchipelagoTotalChecksObjectiveController.TotalChecks;
finishedAllChecks = true;
}
return false;
}
return true;
}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("com.Ijwu.Archipelago", "Archipelago", "1.5.3")]
public class ArchipelagoPlugin : BaseUnityPlugin
{
public const string PluginGUID = "com.Ijwu.Archipelago";
public const string PluginAuthor = "Ijwu/Sneaki";
public const string PluginName = "Archipelago";
public const string PluginVersion = "1.5.3";
private ArchipelagoClient AP;
private ClientItemsHandler ClientItems;
internal static string apServerUri = "archipelago.gg";
internal static int apServerPort = 38281;
private bool willConnectToAP = true;
private bool isPlayingAP = false;
internal static string apSlotName = "";
internal static string apPassword;
public static ConfigEntry<bool> SatelliteEntry { get; set; }
public static ConfigEntry<string> SlotNameEntry { get; set; }
public static ConfigEntry<string> ServerNameEntry { get; set; }
public static ConfigEntry<int> PortEntry { get; set; }
public static ConfigEntry<string> PasswordEntry { get; set; }
internal static ArchipelagoPlugin Instance { get; private set; }
public void Awake()
{
//IL_010d: Unknown result type (might be due to invalid IL or missing references)
//IL_0117: Expected O, but got Unknown
Log.Init(((BaseUnityPlugin)this).Logger);
CreateConfigurations();
apSlotName = SlotNameEntry.Value;
apServerUri = ServerNameEntry.Value;
apServerPort = PortEntry.Value;
apPassword = PasswordEntry.Value;
Instance = this;
AP = new ArchipelagoClient();
ArchipelagoConnectButtonController.OnConnectClick = (ArchipelagoConnectButtonController.ConnectClicked)Delegate.Combine(ArchipelagoConnectButtonController.OnConnectClick, new ArchipelagoConnectButtonController.ConnectClicked(OnClick_ConnectToArchipelagoWithButton));
AP.OnClientDisconnect += AP_OnClientDisconnect;
Run.onRunDestroyGlobal += Run_onRunDestroyGlobal;
ArchipelagoStartMessage.OnArchipelagoSessionStart += ArchipelagoStartMessage_OnArchipelagoSessionStart;
ArchipelagoEndMessage.OnArchipelagoSessionEnd += ArchipelagoEndMessage_OnArchipelagoSessionEnd;
ArchipelagoConsoleCommand.OnArchipelagoCommandCalled += ArchipelagoConsoleCommand_ArchipelagoCommandCalled;
ArchipelagoConsoleCommand.OnArchipelagoDisconnectCommandCalled += ArchipelagoConsoleCommand_ArchipelagoDisconnectCommandCalled;
NetworkManagerSystem.onStopClientGlobal += GameNetworkManager_onStopClientGlobal;
ChatBox.SubmitChat += new hook_SubmitChat(ChatBox_SubmitChat);
AssetBundleHelper.LoadBundle();
CreateLobbyFields();
NetworkingAPI.RegisterMessageType<SyncLocationCheckProgress>();
NetworkingAPI.RegisterMessageType<ArchipelagoStartMessage>();
NetworkingAPI.RegisterMessageType<ArchipelagoEndMessage>();
NetworkingAPI.RegisterMessageType<SyncTotalCheckProgress>();
NetworkingAPI.RegisterMessageType<AllChecksComplete>();
NetworkingAPI.RegisterMessageType<AllChecksCompleteInStage>();
NetworkingAPI.RegisterMessageType<ArchipelagoChatMessage>();
NetworkingAPI.RegisterMessageType<SyncCurrentEnvironmentCheckProgress>();
NetworkingAPI.RegisterMessageType<NextStageObjectives>();
NetworkingAPI.RegisterMessageType<ArchipelagoTeleportClient>();
NetworkingAPI.RegisterMessageType<SyncShrineCheckProgress>();
NetworkingAPI.RegisterMessageType<ArchipelagoStartExplore>();
CommandHelper.AddToConsoleWhenReady();
}
public void Start()
{
//IL_0006: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
GameObject val = new GameObject("ArchipelagoConnectButtonController");
val.AddComponent<ArchipelagoConnectButtonController>();
}
private void GameNetworkManager_onStopClientGlobal()
{
if (!NetworkServer.active && isPlayingAP && AP.itemCheckBar != null)
{
AP.itemCheckBar.Dispose();
}
}
private void ChatBox_SubmitChat(orig_SubmitChat orig, ChatBox self)
{
if (!NetworkServer.active && isPlayingAP)
{
NetMessageExtensions.Send((INetMessage)(object)new ArchipelagoChatMessage(self.inputField.text), (NetworkDestination)2);
self.inputField.text = "";
orig.Invoke(self);
}
else
{
orig.Invoke(self);
}
}
private void ArchipelagoEndMessage_OnArchipelagoSessionEnd()
{
if (!NetworkServer.active && isPlayingAP && AP.itemCheckBar != null)
{
AP.itemCheckBar.Dispose();
}
}
private void AP_OnClientDisconnect(string reason)
{
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
Log.LogWarning("Archipelago client was disconnected from the server because `" + reason + "`");
ChatMessage.SendColored("Archipelago client was disconnected from the server. " + reason, Color.red);
bool flag = NetworkServer.active && RoR2Application.isInMultiPlayer;
if (!isPlayingAP || flag || RoR2Application.isInSinglePlayer)
{
}
if (AP.reconnecting)
{
((MonoBehaviour)this).StartCoroutine((System.Collections.IEnumerator)AP.AttemptReconnection());
}
}
public void OnClick_ConnectToArchipelagoWithButton()
{
isPlayingAP = true;
string url = apServerUri + ":" + apServerPort;
Log.LogDebug($"Server {apServerUri} Port: {apServerPort} Slot: {apSlotName} Password: {apPassword}");
AP.Connect(url, apSlotName, apPassword);
SlotNameEntry.Value = apSlotName;
}
private void ArchipelagoConsoleCommand_ArchipelagoCommandCalled(string url, int port, string slot, string password)
{
willConnectToAP = true;
isPlayingAP = true;
url = url + ":" + port;
AP.Connect(url, slot, password);
}
private void ArchipelagoConsoleCommand_ArchipelagoDisconnectCommandCalled()
{
AP.Disconnect();
}
private void ArchipelagoStartMessage_OnArchipelagoSessionStart()
{
if (!NetworkServer.active)
{
ClientItems = new ClientItemsHandler();
ClientItems?.Hook();
isPlayingAP = true;
}
}
private void Run_onRunDestroyGlobal(Run obj)
{
if (isPlayingAP)
{
ArchipelagoTotalChecksObjectiveController.RemoveObjective();
ArchipelagoLocationsInEnvironmentController.RemoveObjective();
}
}
private void CreateLobbyFields()
{
ArchipelagoConnectButtonController.OnSlotChanged = (string newValue) => apSlotName = newValue;
ArchipelagoConnectButtonController.OnPasswordChanged = (string newValue) => apPassword = newValue;
ArchipelagoConnectButtonController.OnUrlChanged = (string newValue) => apServerUri = newValue;
ArchipelagoConnectButtonController.OnPortChanged = ChangePort;
}
private void CreateConfigurations()
{
SatelliteEntry = ((BaseUnityPlugin)this).Config.Bind<bool>("HighlightSatellite", "satellite", true, "This will highlight all satellites");
SlotNameEntry = ((BaseUnityPlugin)this).Config.Bind<string>("SlotName", "slotName", "", "Change the default slot name");
ServerNameEntry = ((BaseUnityPlugin)this).Config.Bind<string>("ServerName", "serverName", "archipelago.gg", "Change the default server name");
PortEntry = ((BaseUnityPlugin)this).Config.Bind<int>("Port", "port", 38281, "Change the default port");
PasswordEntry = ((BaseUnityPlugin)this).Config.Bind<string>("Password", "password", "", "Change the default password");
}
private string ChangePort(string newValue)
{
apServerPort = int.Parse(newValue);
return newValue;
}
}
public interface IEnumerator
{
}
internal static class Log
{
internal static ManualLogSource _logSource;
internal static void Init(ManualLogSource logSource)
{
_logSource = logSource;
}
internal static void LogDebug(object data)
{
_logSource.LogDebug(data);
}
internal static void LogError(object data)
{
_logSource.LogError(data);
}
internal static void LogFatal(object data)
{
_logSource.LogFatal(data);
}
internal static void LogInfo(object data)
{
_logSource.LogInfo(data);
}
internal static void LogMessage(object data)
{
_logSource.LogMessage(data);
}
internal static void LogWarning(object data)
{
_logSource.LogWarning(data);
}
}
}
namespace Archipelago.RiskOfRain2.UI
{
public class ArchipelagoConnectButtonController : MonoBehaviour
{
public delegate string SlotChanged(string newValue);
public delegate string PasswordChanged(string newValue);
public delegate string UrlChanged(string newValue);
public delegate string PortChanged(string newValue);
public delegate void ConnectClicked();
[Serializable]
[CompilerGenerated]
private sealed class <>c
{
public static readonly <>c <>9 = new <>c();
public static UnityAction <>9__28_0;
public static UnityAction<string> <>9__29_0;
public static UnityAction<string> <>9__29_1;
public static UnityAction<string> <>9__29_2;
public static UnityAction<string> <>9__29_3;
public static UnityAction <>9__30_0;
internal void <CreateButton>b__28_0()
{
OnConnectClick();
}
internal void <CreateFields>b__29_0(string value)
{
OnSlotChangusing System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Collections.Specialized;
using System.ComponentModel;
using System.Data;
using System.Data.SqlTypes;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Linq;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json.Bson;
using Newtonsoft.Json.Converters;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Linq.JsonPath;
using Newtonsoft.Json.Schema;
using Newtonsoft.Json.Serialization;
using Newtonsoft.Json.Utilities;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AllowPartiallyTrustedCallers]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Schema, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100f561df277c6c0b497d629032b410cdcf286e537c054724f7ffa0164345f62b3e642029d7a80cc351918955328c4adc8a048823ef90b0cf38ea7db0d729caf2b633c3babe08b0310198c1081995c19029bc675193744eab9d7345b8a67258ec17d112cebdbbb2a281487dceeafb9d83aa930f32103fbe1d2911425bc5744002c7")]
[assembly: InternalsVisibleTo("Newtonsoft.Json.Dynamic, PublicKey=0024000004800000940000000602000000240000525341310004000001000100cbd8d53b9d7de30f1f1278f636ec462cf9c254991291e66ebb157a885638a517887633b898ccbcf0d5c5ff7be85a6abe9e765d0ac7cd33c68dac67e7e64530e8222101109f154ab14a941c490ac155cd1d4fcba0fabb49016b4ef28593b015cab5937da31172f03f67d09edda404b88a60023f062ae71d0b2e4438b74cc11dc9")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("9ca358aa-317b-4925-8ada-4a29e943a363")]
[assembly: CLSCompliant(true)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[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 Standard 2.0")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/JamesNK/Newtonsoft.Json")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyVersion("13.0.0.0")]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class IsReadOnlyAttribute : Attribute
{
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
}
namespace System.Diagnostics.CodeAnalysis
{
[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true)]
internal sealed class NotNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false)]
internal sealed class NotNullWhenAttribute : Attribute
{
public bool ReturnValue { get; }
public NotNullWhenAttribute(bool returnValue)
{
ReturnValue = returnValue;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
internal sealed class MaybeNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
internal sealed class AllowNullAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
internal class DoesNotReturnIfAttribute : Attribute
{
public bool ParameterValue { get; }
public DoesNotReturnIfAttribute(bool parameterValue)
{
ParameterValue = parameterValue;
}
}
}
namespace Newtonsoft.Json
{
public enum ConstructorHandling
{
Default,
AllowNonPublicDefaultConstructor
}
public enum DateFormatHandling
{
IsoDateFormat,
MicrosoftDateFormat
}
public enum DateParseHandling
{
None,
DateTime,
DateTimeOffset
}
public enum DateTimeZoneHandling
{
Local,
Utc,
Unspecified,
RoundtripKind
}
public class DefaultJsonNameTable : JsonNameTable
{
private class Entry
{
internal readonly string Value;
internal readonly int HashCode;
internal Entry Next;
internal Entry(string value, int hashCode, Entry next)
{
Value = value;
HashCode = hashCode;
Next = next;
}
}
private static readonly int HashCodeRandomizer;
private int _count;
private Entry[] _entries;
private int _mask = 31;
static DefaultJsonNameTable()
{
HashCodeRandomizer = Environment.TickCount;
}
public DefaultJsonNameTable()
{
_entries = new Entry[_mask + 1];
}
public override string? Get(char[] key, int start, int length)
{
if (length == 0)
{
return string.Empty;
}
int num = length + HashCodeRandomizer;
num += (num << 7) ^ key[start];
int num2 = start + length;
for (int i = start + 1; i < num2; i++)
{
num += (num << 7) ^ key[i];
}
num -= num >> 17;
num -= num >> 11;
num -= num >> 5;
int num3 = Volatile.Read(ref _mask);
int num4 = num & num3;
for (Entry entry = _entries[num4]; entry != null; entry = entry.Next)
{
if (entry.HashCode == num && TextEquals(entry.Value, key, start, length))
{
return entry.Value;
}
}
return null;
}
public string Add(string key)
{
if (key == null)
{
throw new ArgumentNullException("key");
}
int length = key.Length;
if (length == 0)
{
return string.Empty;
}
int num = length + HashCodeRandomizer;
for (int i = 0; i < key.Length; i++)
{
num += (num << 7) ^ key[i];
}
num -= num >> 17;
num -= num >> 11;
num -= num >> 5;
for (Entry entry = _entries[num & _mask]; entry != null; entry = entry.Next)
{
if (entry.HashCode == num && entry.Value.Equals(key, StringComparison.Ordinal))
{
return entry.Value;
}
}
return AddEntry(key, num);
}
private string AddEntry(string str, int hashCode)
{
int num = hashCode & _mask;
Entry entry = new Entry(str, hashCode, _entries[num]);
_entries[num] = entry;
if (_count++ == _mask)
{
Grow();
}
return entry.Value;
}
private void Grow()
{
Entry[] entries = _entries;
int num = _mask * 2 + 1;
Entry[] array = new Entry[num + 1];
for (int i = 0; i < entries.Length; i++)
{
Entry entry = entries[i];
while (entry != null)
{
int num2 = entry.HashCode & num;
Entry next = entry.Next;
entry.Next = array[num2];
array[num2] = entry;
entry = next;
}
}
_entries = array;
Volatile.Write(ref _mask, num);
}
private static bool TextEquals(string str1, char[] str2, int str2Start, int str2Length)
{
if (str1.Length != str2Length)
{
return false;
}
for (int i = 0; i < str1.Length; i++)
{
if (str1[i] != str2[str2Start + i])
{
return false;
}
}
return true;
}
}
[Flags]
public enum DefaultValueHandling
{
Include = 0,
Ignore = 1,
Populate = 2,
IgnoreAndPopulate = 3
}
public enum FloatFormatHandling
{
String,
Symbol,
DefaultValue
}
public enum FloatParseHandling
{
Double,
Decimal
}
public enum Formatting
{
None,
Indented
}
public interface IArrayPool<T>
{
T[] Rent(int minimumLength);
void Return(T[]? array);
}
public interface IJsonLineInfo
{
int LineNumber { get; }
int LinePosition { get; }
bool HasLineInfo();
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonArrayAttribute : JsonContainerAttribute
{
private bool _allowNullItems;
public bool AllowNullItems
{
get
{
return _allowNullItems;
}
set
{
_allowNullItems = value;
}
}
public JsonArrayAttribute()
{
}
public JsonArrayAttribute(bool allowNullItems)
{
_allowNullItems = allowNullItems;
}
public JsonArrayAttribute(string id)
: base(id)
{
}
}
[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false)]
public sealed class JsonConstructorAttribute : Attribute
{
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public abstract class JsonContainerAttribute : Attribute
{
internal bool? _isReference;
internal bool? _itemIsReference;
internal ReferenceLoopHandling? _itemReferenceLoopHandling;
internal TypeNameHandling? _itemTypeNameHandling;
private Type? _namingStrategyType;
private object[]? _namingStrategyParameters;
public string? Id { get; set; }
public string? Title { get; set; }
public string? Description { get; set; }
public Type? ItemConverterType { get; set; }
public object[]? ItemConverterParameters { get; set; }
public Type? NamingStrategyType
{
get
{
return _namingStrategyType;
}
set
{
_namingStrategyType = value;
NamingStrategyInstance = null;
}
}
public object[]? NamingStrategyParameters
{
get
{
return _namingStrategyParameters;
}
set
{
_namingStrategyParameters = value;
NamingStrategyInstance = null;
}
}
internal NamingStrategy? NamingStrategyInstance { get; set; }
public bool IsReference
{
get
{
return _isReference.GetValueOrDefault();
}
set
{
_isReference = value;
}
}
public bool ItemIsReference
{
get
{
return _itemIsReference.GetValueOrDefault();
}
set
{
_itemIsReference = value;
}
}
public ReferenceLoopHandling ItemReferenceLoopHandling
{
get
{
return _itemReferenceLoopHandling.GetValueOrDefault();
}
set
{
_itemReferenceLoopHandling = value;
}
}
public TypeNameHandling ItemTypeNameHandling
{
get
{
return _itemTypeNameHandling.GetValueOrDefault();
}
set
{
_itemTypeNameHandling = value;
}
}
protected JsonContainerAttribute()
{
}
protected JsonContainerAttribute(string id)
{
Id = id;
}
}
public static class JsonConvert
{
public static readonly string True = "true";
public static readonly string False = "false";
public static readonly string Null = "null";
public static readonly string Undefined = "undefined";
public static readonly string PositiveInfinity = "Infinity";
public static readonly string NegativeInfinity = "-Infinity";
public static readonly string NaN = "NaN";
public static Func<JsonSerializerSettings>? DefaultSettings { get; set; }
public static string ToString(DateTime value)
{
return ToString(value, DateFormatHandling.IsoDateFormat, DateTimeZoneHandling.RoundtripKind);
}
public static string ToString(DateTime value, DateFormatHandling format, DateTimeZoneHandling timeZoneHandling)
{
DateTime value2 = DateTimeUtils.EnsureDateTime(value, timeZoneHandling);
using StringWriter stringWriter = StringUtils.CreateStringWriter(64);
stringWriter.Write('"');
DateTimeUtils.WriteDateTimeString(stringWriter, value2, format, null, CultureInfo.InvariantCulture);
stringWriter.Write('"');
return stringWriter.ToString();
}
public static string ToString(DateTimeOffset value)
{
return ToString(value, DateFormatHandling.IsoDateFormat);
}
public static string ToString(DateTimeOffset value, DateFormatHandling format)
{
using StringWriter stringWriter = StringUtils.CreateStringWriter(64);
stringWriter.Write('"');
DateTimeUtils.WriteDateTimeOffsetString(stringWriter, value, format, null, CultureInfo.InvariantCulture);
stringWriter.Write('"');
return stringWriter.ToString();
}
public static string ToString(bool value)
{
if (!value)
{
return False;
}
return True;
}
public static string ToString(char value)
{
return ToString(char.ToString(value));
}
public static string ToString(Enum value)
{
return value.ToString("D");
}
public static string ToString(int value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(short value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(ushort value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(uint value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(long value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
private static string ToStringInternal(BigInteger value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(ulong value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(float value)
{
return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
}
internal static string ToString(float value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
}
private static string EnsureFloatFormat(double value, string text, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
if (floatFormatHandling == FloatFormatHandling.Symbol || (!double.IsInfinity(value) && !double.IsNaN(value)))
{
return text;
}
if (floatFormatHandling == FloatFormatHandling.DefaultValue)
{
if (nullable)
{
return Null;
}
return "0.0";
}
return quoteChar + text + quoteChar;
}
public static string ToString(double value)
{
return EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture));
}
internal static string ToString(double value, FloatFormatHandling floatFormatHandling, char quoteChar, bool nullable)
{
return EnsureFloatFormat(value, EnsureDecimalPlace(value, value.ToString("R", CultureInfo.InvariantCulture)), floatFormatHandling, quoteChar, nullable);
}
private static string EnsureDecimalPlace(double value, string text)
{
if (double.IsNaN(value) || double.IsInfinity(value) || StringUtils.IndexOf(text, '.') != -1 || StringUtils.IndexOf(text, 'E') != -1 || StringUtils.IndexOf(text, 'e') != -1)
{
return text;
}
return text + ".0";
}
private static string EnsureDecimalPlace(string text)
{
if (StringUtils.IndexOf(text, '.') != -1)
{
return text;
}
return text + ".0";
}
public static string ToString(byte value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
[CLSCompliant(false)]
public static string ToString(sbyte value)
{
return value.ToString(null, CultureInfo.InvariantCulture);
}
public static string ToString(decimal value)
{
return EnsureDecimalPlace(value.ToString(null, CultureInfo.InvariantCulture));
}
public static string ToString(Guid value)
{
return ToString(value, '"');
}
internal static string ToString(Guid value, char quoteChar)
{
string text = value.ToString("D", CultureInfo.InvariantCulture);
string text2 = quoteChar.ToString(CultureInfo.InvariantCulture);
return text2 + text + text2;
}
public static string ToString(TimeSpan value)
{
return ToString(value, '"');
}
internal static string ToString(TimeSpan value, char quoteChar)
{
return ToString(value.ToString(), quoteChar);
}
public static string ToString(Uri? value)
{
if (value == null)
{
return Null;
}
return ToString(value, '"');
}
internal static string ToString(Uri value, char quoteChar)
{
return ToString(value.OriginalString, quoteChar);
}
public static string ToString(string? value)
{
return ToString(value, '"');
}
public static string ToString(string? value, char delimiter)
{
return ToString(value, delimiter, StringEscapeHandling.Default);
}
public static string ToString(string? value, char delimiter, StringEscapeHandling stringEscapeHandling)
{
if (delimiter != '"' && delimiter != '\'')
{
throw new ArgumentException("Delimiter must be a single or double quote.", "delimiter");
}
return JavaScriptUtils.ToEscapedJavaScriptString(value, delimiter, appendDelimiters: true, stringEscapeHandling);
}
public static string ToString(object? value)
{
if (value == null)
{
return Null;
}
return ConvertUtils.GetTypeCode(value.GetType()) switch
{
PrimitiveTypeCode.String => ToString((string)value),
PrimitiveTypeCode.Char => ToString((char)value),
PrimitiveTypeCode.Boolean => ToString((bool)value),
PrimitiveTypeCode.SByte => ToString((sbyte)value),
PrimitiveTypeCode.Int16 => ToString((short)value),
PrimitiveTypeCode.UInt16 => ToString((ushort)value),
PrimitiveTypeCode.Int32 => ToString((int)value),
PrimitiveTypeCode.Byte => ToString((byte)value),
PrimitiveTypeCode.UInt32 => ToString((uint)value),
PrimitiveTypeCode.Int64 => ToString((long)value),
PrimitiveTypeCode.UInt64 => ToString((ulong)value),
PrimitiveTypeCode.Single => ToString((float)value),
PrimitiveTypeCode.Double => ToString((double)value),
PrimitiveTypeCode.DateTime => ToString((DateTime)value),
PrimitiveTypeCode.Decimal => ToString((decimal)value),
PrimitiveTypeCode.DBNull => Null,
PrimitiveTypeCode.DateTimeOffset => ToString((DateTimeOffset)value),
PrimitiveTypeCode.Guid => ToString((Guid)value),
PrimitiveTypeCode.Uri => ToString((Uri)value),
PrimitiveTypeCode.TimeSpan => ToString((TimeSpan)value),
PrimitiveTypeCode.BigInteger => ToStringInternal((BigInteger)value),
_ => throw new ArgumentException("Unsupported type: {0}. Use the JsonSerializer class to get the object's JSON representation.".FormatWith(CultureInfo.InvariantCulture, value.GetType())),
};
}
[DebuggerStepThrough]
public static string SerializeObject(object? value)
{
return SerializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Formatting formatting)
{
return SerializeObject(value, formatting, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, params JsonConverter[] converters)
{
JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
{
Converters = converters
} : null);
return SerializeObject(value, null, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Formatting formatting, params JsonConverter[] converters)
{
JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
{
Converters = converters
} : null);
return SerializeObject(value, null, formatting, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, JsonSerializerSettings? settings)
{
return SerializeObject(value, null, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Type? type, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
return SerializeObjectInternal(value, type, jsonSerializer);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Formatting formatting, JsonSerializerSettings? settings)
{
return SerializeObject(value, null, formatting, settings);
}
[DebuggerStepThrough]
public static string SerializeObject(object? value, Type? type, Formatting formatting, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
jsonSerializer.Formatting = formatting;
return SerializeObjectInternal(value, type, jsonSerializer);
}
private static string SerializeObjectInternal(object? value, Type? type, JsonSerializer jsonSerializer)
{
StringWriter stringWriter = new StringWriter(new StringBuilder(256), CultureInfo.InvariantCulture);
using (JsonTextWriter jsonTextWriter = new JsonTextWriter(stringWriter))
{
jsonTextWriter.Formatting = jsonSerializer.Formatting;
jsonSerializer.Serialize(jsonTextWriter, value, type);
}
return stringWriter.ToString();
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value)
{
return DeserializeObject(value, (Type?)null, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value, JsonSerializerSettings settings)
{
return DeserializeObject(value, null, settings);
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value, Type type)
{
return DeserializeObject(value, type, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static T? DeserializeObject<T>(string value)
{
return JsonConvert.DeserializeObject<T>(value, (JsonSerializerSettings?)null);
}
[DebuggerStepThrough]
public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject)
{
return DeserializeObject<T>(value);
}
[DebuggerStepThrough]
public static T? DeserializeAnonymousType<T>(string value, T anonymousTypeObject, JsonSerializerSettings settings)
{
return DeserializeObject<T>(value, settings);
}
[DebuggerStepThrough]
public static T? DeserializeObject<T>(string value, params JsonConverter[] converters)
{
return (T)DeserializeObject(value, typeof(T), converters);
}
[DebuggerStepThrough]
public static T? DeserializeObject<T>(string value, JsonSerializerSettings? settings)
{
return (T)DeserializeObject(value, typeof(T), settings);
}
[DebuggerStepThrough]
public static object? DeserializeObject(string value, Type type, params JsonConverter[] converters)
{
JsonSerializerSettings settings = ((converters != null && converters.Length != 0) ? new JsonSerializerSettings
{
Converters = converters
} : null);
return DeserializeObject(value, type, settings);
}
public static object? DeserializeObject(string value, Type? type, JsonSerializerSettings? settings)
{
ValidationUtils.ArgumentNotNull(value, "value");
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
if (!jsonSerializer.IsCheckAdditionalContentSet())
{
jsonSerializer.CheckAdditionalContent = true;
}
using JsonTextReader reader = new JsonTextReader(new StringReader(value));
return jsonSerializer.Deserialize(reader, type);
}
[DebuggerStepThrough]
public static void PopulateObject(string value, object target)
{
PopulateObject(value, target, null);
}
public static void PopulateObject(string value, object target, JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = JsonSerializer.CreateDefault(settings);
using JsonReader jsonReader = new JsonTextReader(new StringReader(value));
jsonSerializer.Populate(jsonReader, target);
if (settings == null || !settings.CheckAdditionalContent)
{
return;
}
while (jsonReader.Read())
{
if (jsonReader.TokenType != JsonToken.Comment)
{
throw JsonSerializationException.Create(jsonReader, "Additional text found in JSON string after finishing deserializing object.");
}
}
}
public static string SerializeXmlNode(XmlNode? node)
{
return SerializeXmlNode(node, Formatting.None);
}
public static string SerializeXmlNode(XmlNode? node, Formatting formatting)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
return SerializeObject(node, formatting, xmlNodeConverter);
}
public static string SerializeXmlNode(XmlNode? node, Formatting formatting, bool omitRootObject)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
{
OmitRootObject = omitRootObject
};
return SerializeObject(node, formatting, xmlNodeConverter);
}
public static XmlDocument? DeserializeXmlNode(string value)
{
return DeserializeXmlNode(value, null);
}
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName)
{
return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute: false);
}
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
{
return DeserializeXmlNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
}
public static XmlDocument? DeserializeXmlNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute;
xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters;
return (XmlDocument)DeserializeObject(value, typeof(XmlDocument), xmlNodeConverter);
}
public static string SerializeXNode(XObject? node)
{
return SerializeXNode(node, Formatting.None);
}
public static string SerializeXNode(XObject? node, Formatting formatting)
{
return SerializeXNode(node, formatting, omitRootObject: false);
}
public static string SerializeXNode(XObject? node, Formatting formatting, bool omitRootObject)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
{
OmitRootObject = omitRootObject
};
return SerializeObject(node, formatting, xmlNodeConverter);
}
public static XDocument? DeserializeXNode(string value)
{
return DeserializeXNode(value, null);
}
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName)
{
return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute: false);
}
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute)
{
return DeserializeXNode(value, deserializeRootElementName, writeArrayAttribute, encodeSpecialCharacters: false);
}
public static XDocument? DeserializeXNode(string value, string? deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
{
XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
xmlNodeConverter.WriteArrayAttribute = writeArrayAttribute;
xmlNodeConverter.EncodeSpecialCharacters = encodeSpecialCharacters;
return (XDocument)DeserializeObject(value, typeof(XDocument), xmlNodeConverter);
}
}
public abstract class JsonConverter
{
public virtual bool CanRead => true;
public virtual bool CanWrite => true;
public abstract void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer);
public abstract object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer);
public abstract bool CanConvert(Type objectType);
}
public abstract class JsonConverter<T> : JsonConverter
{
public sealed override void WriteJson(JsonWriter writer, object? value, JsonSerializer serializer)
{
if (!((value != null) ? (value is T) : ReflectionUtils.IsNullable(typeof(T))))
{
throw new JsonSerializationException("Converter cannot write specified value to JSON. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
}
WriteJson(writer, (T)value, serializer);
}
public abstract void WriteJson(JsonWriter writer, T? value, JsonSerializer serializer);
public sealed override object? ReadJson(JsonReader reader, Type objectType, object? existingValue, JsonSerializer serializer)
{
bool flag = existingValue == null;
if (!flag && !(existingValue is T))
{
throw new JsonSerializationException("Converter cannot read JSON with the specified existing value. {0} is required.".FormatWith(CultureInfo.InvariantCulture, typeof(T)));
}
return ReadJson(reader, objectType, flag ? default(T) : ((T)existingValue), !flag, serializer);
}
public abstract T? ReadJson(JsonReader reader, Type objectType, T? existingValue, bool hasExistingValue, JsonSerializer serializer);
public sealed override bool CanConvert(Type objectType)
{
return typeof(T).IsAssignableFrom(objectType);
}
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface | AttributeTargets.Parameter, AllowMultiple = false)]
public sealed class JsonConverterAttribute : Attribute
{
private readonly Type _converterType;
public Type ConverterType => _converterType;
public object[]? ConverterParameters { get; }
public JsonConverterAttribute(Type converterType)
{
if (converterType == null)
{
throw new ArgumentNullException("converterType");
}
_converterType = converterType;
}
public JsonConverterAttribute(Type converterType, params object[] converterParameters)
: this(converterType)
{
ConverterParameters = converterParameters;
}
}
public class JsonConverterCollection : Collection<JsonConverter>
{
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonDictionaryAttribute : JsonContainerAttribute
{
public JsonDictionaryAttribute()
{
}
public JsonDictionaryAttribute(string id)
: base(id)
{
}
}
[Serializable]
public class JsonException : Exception
{
public JsonException()
{
}
public JsonException(string message)
: base(message)
{
}
public JsonException(string message, Exception? innerException)
: base(message, innerException)
{
}
public JsonException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
internal static JsonException Create(IJsonLineInfo lineInfo, string path, string message)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
return new JsonException(message);
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public class JsonExtensionDataAttribute : Attribute
{
public bool WriteData { get; set; }
public bool ReadData { get; set; }
public JsonExtensionDataAttribute()
{
WriteData = true;
ReadData = true;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public sealed class JsonIgnoreAttribute : Attribute
{
}
public abstract class JsonNameTable
{
public abstract string? Get(char[] key, int start, int length);
}
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Interface, AllowMultiple = false)]
public sealed class JsonObjectAttribute : JsonContainerAttribute
{
private MemberSerialization _memberSerialization;
internal MissingMemberHandling? _missingMemberHandling;
internal Required? _itemRequired;
internal NullValueHandling? _itemNullValueHandling;
public MemberSerialization MemberSerialization
{
get
{
return _memberSerialization;
}
set
{
_memberSerialization = value;
}
}
public MissingMemberHandling MissingMemberHandling
{
get
{
return _missingMemberHandling.GetValueOrDefault();
}
set
{
_missingMemberHandling = value;
}
}
public NullValueHandling ItemNullValueHandling
{
get
{
return _itemNullValueHandling.GetValueOrDefault();
}
set
{
_itemNullValueHandling = value;
}
}
public Required ItemRequired
{
get
{
return _itemRequired.GetValueOrDefault();
}
set
{
_itemRequired = value;
}
}
public JsonObjectAttribute()
{
}
public JsonObjectAttribute(MemberSerialization memberSerialization)
{
MemberSerialization = memberSerialization;
}
public JsonObjectAttribute(string id)
: base(id)
{
}
}
internal enum JsonContainerType
{
None,
Object,
Array,
Constructor
}
internal struct JsonPosition
{
private static readonly char[] SpecialCharacters = new char[18]
{
'.', ' ', '\'', '/', '"', '[', ']', '(', ')', '\t',
'\n', '\r', '\f', '\b', '\\', '\u0085', '\u2028', '\u2029'
};
internal JsonContainerType Type;
internal int Position;
internal string? PropertyName;
internal bool HasIndex;
public JsonPosition(JsonContainerType type)
{
Type = type;
HasIndex = TypeHasIndex(type);
Position = -1;
PropertyName = null;
}
internal int CalculateLength()
{
switch (Type)
{
case JsonContainerType.Object:
return PropertyName.Length + 5;
case JsonContainerType.Array:
case JsonContainerType.Constructor:
return MathUtils.IntLength((ulong)Position) + 2;
default:
throw new ArgumentOutOfRangeException("Type");
}
}
internal void WriteTo(StringBuilder sb, ref StringWriter? writer, ref char[]? buffer)
{
switch (Type)
{
case JsonContainerType.Object:
{
string propertyName = PropertyName;
if (propertyName.IndexOfAny(SpecialCharacters) != -1)
{
sb.Append("['");
if (writer == null)
{
writer = new StringWriter(sb);
}
JavaScriptUtils.WriteEscapedJavaScriptString(writer, propertyName, '\'', appendDelimiters: false, JavaScriptUtils.SingleQuoteCharEscapeFlags, StringEscapeHandling.Default, null, ref buffer);
sb.Append("']");
}
else
{
if (sb.Length > 0)
{
sb.Append('.');
}
sb.Append(propertyName);
}
break;
}
case JsonContainerType.Array:
case JsonContainerType.Constructor:
sb.Append('[');
sb.Append(Position);
sb.Append(']');
break;
}
}
internal static bool TypeHasIndex(JsonContainerType type)
{
if (type != JsonContainerType.Array)
{
return type == JsonContainerType.Constructor;
}
return true;
}
internal static string BuildPath(List<JsonPosition> positions, JsonPosition? currentPosition)
{
int num = 0;
if (positions != null)
{
for (int i = 0; i < positions.Count; i++)
{
num += positions[i].CalculateLength();
}
}
if (currentPosition.HasValue)
{
num += currentPosition.GetValueOrDefault().CalculateLength();
}
StringBuilder stringBuilder = new StringBuilder(num);
StringWriter writer = null;
char[] buffer = null;
if (positions != null)
{
foreach (JsonPosition position in positions)
{
position.WriteTo(stringBuilder, ref writer, ref buffer);
}
}
currentPosition?.WriteTo(stringBuilder, ref writer, ref buffer);
return stringBuilder.ToString();
}
internal static string FormatMessage(IJsonLineInfo? lineInfo, string path, string message)
{
if (!message.EndsWith(Environment.NewLine, StringComparison.Ordinal))
{
message = message.Trim();
if (!StringUtils.EndsWith(message, '.'))
{
message += ".";
}
message += " ";
}
message += "Path '{0}'".FormatWith(CultureInfo.InvariantCulture, path);
if (lineInfo != null && lineInfo.HasLineInfo())
{
message += ", line {0}, position {1}".FormatWith(CultureInfo.InvariantCulture, lineInfo.LineNumber, lineInfo.LinePosition);
}
message += ".";
return message;
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, AllowMultiple = false)]
public sealed class JsonPropertyAttribute : Attribute
{
internal NullValueHandling? _nullValueHandling;
internal DefaultValueHandling? _defaultValueHandling;
internal ReferenceLoopHandling? _referenceLoopHandling;
internal ObjectCreationHandling? _objectCreationHandling;
internal TypeNameHandling? _typeNameHandling;
internal bool? _isReference;
internal int? _order;
internal Required? _required;
internal bool? _itemIsReference;
internal ReferenceLoopHandling? _itemReferenceLoopHandling;
internal TypeNameHandling? _itemTypeNameHandling;
public Type? ItemConverterType { get; set; }
public object[]? ItemConverterParameters { get; set; }
public Type? NamingStrategyType { get; set; }
public object[]? NamingStrategyParameters { get; set; }
public NullValueHandling NullValueHandling
{
get
{
return _nullValueHandling.GetValueOrDefault();
}
set
{
_nullValueHandling = value;
}
}
public DefaultValueHandling DefaultValueHandling
{
get
{
return _defaultValueHandling.GetValueOrDefault();
}
set
{
_defaultValueHandling = value;
}
}
public ReferenceLoopHandling ReferenceLoopHandling
{
get
{
return _referenceLoopHandling.GetValueOrDefault();
}
set
{
_referenceLoopHandling = value;
}
}
public ObjectCreationHandling ObjectCreationHandling
{
get
{
return _objectCreationHandling.GetValueOrDefault();
}
set
{
_objectCreationHandling = value;
}
}
public TypeNameHandling TypeNameHandling
{
get
{
return _typeNameHandling.GetValueOrDefault();
}
set
{
_typeNameHandling = value;
}
}
public bool IsReference
{
get
{
return _isReference.GetValueOrDefault();
}
set
{
_isReference = value;
}
}
public int Order
{
get
{
return _order.GetValueOrDefault();
}
set
{
_order = value;
}
}
public Required Required
{
get
{
return _required.GetValueOrDefault();
}
set
{
_required = value;
}
}
public string? PropertyName { get; set; }
public ReferenceLoopHandling ItemReferenceLoopHandling
{
get
{
return _itemReferenceLoopHandling.GetValueOrDefault();
}
set
{
_itemReferenceLoopHandling = value;
}
}
public TypeNameHandling ItemTypeNameHandling
{
get
{
return _itemTypeNameHandling.GetValueOrDefault();
}
set
{
_itemTypeNameHandling = value;
}
}
public bool ItemIsReference
{
get
{
return _itemIsReference.GetValueOrDefault();
}
set
{
_itemIsReference = value;
}
}
public JsonPropertyAttribute()
{
}
public JsonPropertyAttribute(string propertyName)
{
PropertyName = propertyName;
}
}
public abstract class JsonReader : IDisposable
{
protected internal enum State
{
Start,
Complete,
Property,
ObjectStart,
Object,
ArrayStart,
Array,
Closed,
PostValue,
ConstructorStart,
Constructor,
Error,
Finished
}
private JsonToken _tokenType;
private object? _value;
internal char _quoteChar;
internal State _currentState;
private JsonPosition _currentPosition;
private CultureInfo? _culture;
private DateTimeZoneHandling _dateTimeZoneHandling;
private int? _maxDepth;
private bool _hasExceededMaxDepth;
internal DateParseHandling _dateParseHandling;
internal FloatParseHandling _floatParseHandling;
private string? _dateFormatString;
private List<JsonPosition>? _stack;
protected State CurrentState => _currentState;
public bool CloseInput { get; set; }
public bool SupportMultipleContent { get; set; }
public virtual char QuoteChar
{
get
{
return _quoteChar;
}
protected internal set
{
_quoteChar = value;
}
}
public DateTimeZoneHandling DateTimeZoneHandling
{
get
{
return _dateTimeZoneHandling;
}
set
{
if (value < DateTimeZoneHandling.Local || value > DateTimeZoneHandling.RoundtripKind)
{
throw new ArgumentOutOfRangeException("value");
}
_dateTimeZoneHandling = value;
}
}
public DateParseHandling DateParseHandling
{
get
{
return _dateParseHandling;
}
set
{
if (value < DateParseHandling.None || value > DateParseHandling.DateTimeOffset)
{
throw new ArgumentOutOfRangeException("value");
}
_dateParseHandling = value;
}
}
public FloatParseHandling FloatParseHandling
{
get
{
return _floatParseHandling;
}
set
{
if (value < FloatParseHandling.Double || value > FloatParseHandling.Decimal)
{
throw new ArgumentOutOfRangeException("value");
}
_floatParseHandling = value;
}
}
public string? DateFormatString
{
get
{
return _dateFormatString;
}
set
{
_dateFormatString = value;
}
}
public int? MaxDepth
{
get
{
return _maxDepth;
}
set
{
if (value <= 0)
{
throw new ArgumentException("Value must be positive.", "value");
}
_maxDepth = value;
}
}
public virtual JsonToken TokenType => _tokenType;
public virtual object? Value => _value;
public virtual Type? ValueType => _value?.GetType();
public virtual int Depth
{
get
{
int num = _stack?.Count ?? 0;
if (JsonTokenUtils.IsStartToken(TokenType) || _currentPosition.Type == JsonContainerType.None)
{
return num;
}
return num + 1;
}
}
public virtual string Path
{
get
{
if (_currentPosition.Type == JsonContainerType.None)
{
return string.Empty;
}
JsonPosition? currentPosition = ((_currentState != State.ArrayStart && _currentState != State.ConstructorStart && _currentState != State.ObjectStart) ? new JsonPosition?(_currentPosition) : null);
return JsonPosition.BuildPath(_stack, currentPosition);
}
}
public CultureInfo Culture
{
get
{
return _culture ?? CultureInfo.InvariantCulture;
}
set
{
_culture = value;
}
}
public virtual Task<bool> ReadAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<bool>() ?? Read().ToAsync();
}
public async Task SkipAsync(CancellationToken cancellationToken = default(CancellationToken))
{
if (TokenType == JsonToken.PropertyName)
{
await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
}
if (JsonTokenUtils.IsStartToken(TokenType))
{
int depth = Depth;
while (await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false) && depth < Depth)
{
}
}
}
internal async Task ReaderReadAndAssertAsync(CancellationToken cancellationToken)
{
if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
{
throw CreateUnexpectedEndException();
}
}
public virtual Task<bool?> ReadAsBooleanAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<bool?>() ?? Task.FromResult(ReadAsBoolean());
}
public virtual Task<byte[]?> ReadAsBytesAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<byte[]>() ?? Task.FromResult(ReadAsBytes());
}
internal async Task<byte[]?> ReadArrayIntoByteArrayAsync(CancellationToken cancellationToken)
{
List<byte> buffer = new List<byte>();
do
{
if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
{
SetToken(JsonToken.None);
}
}
while (!ReadArrayElementIntoByteArrayReportDone(buffer));
byte[] array = buffer.ToArray();
SetToken(JsonToken.Bytes, array, updateIndex: false);
return array;
}
public virtual Task<DateTime?> ReadAsDateTimeAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<DateTime?>() ?? Task.FromResult(ReadAsDateTime());
}
public virtual Task<DateTimeOffset?> ReadAsDateTimeOffsetAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<DateTimeOffset?>() ?? Task.FromResult(ReadAsDateTimeOffset());
}
public virtual Task<decimal?> ReadAsDecimalAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<decimal?>() ?? Task.FromResult(ReadAsDecimal());
}
public virtual Task<double?> ReadAsDoubleAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return Task.FromResult(ReadAsDouble());
}
public virtual Task<int?> ReadAsInt32Async(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<int?>() ?? Task.FromResult(ReadAsInt32());
}
public virtual Task<string?> ReadAsStringAsync(CancellationToken cancellationToken = default(CancellationToken))
{
return cancellationToken.CancelIfRequestedAsync<string>() ?? Task.FromResult(ReadAsString());
}
internal async Task<bool> ReadAndMoveToContentAsync(CancellationToken cancellationToken)
{
bool flag = await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
if (flag)
{
flag = await MoveToContentAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
}
return flag;
}
internal Task<bool> MoveToContentAsync(CancellationToken cancellationToken)
{
JsonToken tokenType = TokenType;
if (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
{
return MoveToContentFromNonContentAsync(cancellationToken);
}
return AsyncUtils.True;
}
private async Task<bool> MoveToContentFromNonContentAsync(CancellationToken cancellationToken)
{
JsonToken tokenType;
do
{
if (!(await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
{
return false;
}
tokenType = TokenType;
}
while (tokenType == JsonToken.None || tokenType == JsonToken.Comment);
return true;
}
internal JsonPosition GetPosition(int depth)
{
if (_stack != null && depth < _stack.Count)
{
return _stack[depth];
}
return _currentPosition;
}
protected JsonReader()
{
_currentState = State.Start;
_dateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
_dateParseHandling = DateParseHandling.DateTime;
_floatParseHandling = FloatParseHandling.Double;
_maxDepth = 64;
CloseInput = true;
}
private void Push(JsonContainerType value)
{
UpdateScopeWithFinishedValue();
if (_currentPosition.Type == JsonContainerType.None)
{
_currentPosition = new JsonPosition(value);
return;
}
if (_stack == null)
{
_stack = new List<JsonPosition>();
}
_stack.Add(_currentPosition);
_currentPosition = new JsonPosition(value);
if (!_maxDepth.HasValue || !(Depth + 1 > _maxDepth) || _hasExceededMaxDepth)
{
return;
}
_hasExceededMaxDepth = true;
throw JsonReaderException.Create(this, "The reader's MaxDepth of {0} has been exceeded.".FormatWith(CultureInfo.InvariantCulture, _maxDepth));
}
private JsonContainerType Pop()
{
JsonPosition currentPosition;
if (_stack != null && _stack.Count > 0)
{
currentPosition = _currentPosition;
_currentPosition = _stack[_stack.Count - 1];
_stack.RemoveAt(_stack.Count - 1);
}
else
{
currentPosition = _currentPosition;
_currentPosition = default(JsonPosition);
}
if (_maxDepth.HasValue && Depth <= _maxDepth)
{
_hasExceededMaxDepth = false;
}
return currentPosition.Type;
}
private JsonContainerType Peek()
{
return _currentPosition.Type;
}
public abstract bool Read();
public virtual int? ReadAsInt32()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
object value = Value;
if (value is int)
{
return (int)value;
}
int num;
if (value is BigInteger bigInteger)
{
num = (int)bigInteger;
}
else
{
try
{
num = Convert.ToInt32(value, CultureInfo.InvariantCulture);
}
catch (Exception ex)
{
throw JsonReaderException.Create(this, "Could not convert to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex);
}
}
SetToken(JsonToken.Integer, num, updateIndex: false);
return num;
}
case JsonToken.String:
{
string s = (string)Value;
return ReadInt32String(s);
}
default:
throw JsonReaderException.Create(this, "Error reading integer. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal int? ReadInt32String(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (int.TryParse(s, NumberStyles.Integer, Culture, out var result))
{
SetToken(JsonToken.Integer, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to integer: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual string? ReadAsString()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.String:
return (string)Value;
default:
if (JsonTokenUtils.IsPrimitiveToken(contentToken))
{
object value = Value;
if (value != null)
{
string text = ((!(value is IFormattable formattable)) ? ((value is Uri uri) ? uri.OriginalString : value.ToString()) : formattable.ToString(null, Culture));
SetToken(JsonToken.String, text, updateIndex: false);
return text;
}
}
throw JsonReaderException.Create(this, "Error reading string. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
public virtual byte[]? ReadAsBytes()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.StartObject:
{
ReadIntoWrappedTypeObject();
byte[] array2 = ReadAsBytes();
ReaderReadAndAssert();
if (TokenType != JsonToken.EndObject)
{
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
SetToken(JsonToken.Bytes, array2, updateIndex: false);
return array2;
}
case JsonToken.String:
{
string text = (string)Value;
Guid g;
byte[] array3 = ((text.Length == 0) ? CollectionUtils.ArrayEmpty<byte>() : ((!ConvertUtils.TryConvertGuid(text, out g)) ? Convert.FromBase64String(text) : g.ToByteArray()));
SetToken(JsonToken.Bytes, array3, updateIndex: false);
return array3;
}
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Bytes:
if (Value is Guid guid)
{
byte[] array = guid.ToByteArray();
SetToken(JsonToken.Bytes, array, updateIndex: false);
return array;
}
return (byte[])Value;
case JsonToken.StartArray:
return ReadArrayIntoByteArray();
default:
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal byte[] ReadArrayIntoByteArray()
{
List<byte> list = new List<byte>();
do
{
if (!Read())
{
SetToken(JsonToken.None);
}
}
while (!ReadArrayElementIntoByteArrayReportDone(list));
byte[] array = list.ToArray();
SetToken(JsonToken.Bytes, array, updateIndex: false);
return array;
}
private bool ReadArrayElementIntoByteArrayReportDone(List<byte> buffer)
{
switch (TokenType)
{
case JsonToken.None:
throw JsonReaderException.Create(this, "Unexpected end when reading bytes.");
case JsonToken.Integer:
buffer.Add(Convert.ToByte(Value, CultureInfo.InvariantCulture));
return false;
case JsonToken.EndArray:
return true;
case JsonToken.Comment:
return false;
default:
throw JsonReaderException.Create(this, "Unexpected token when reading bytes: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
}
public virtual double? ReadAsDouble()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
object value = Value;
if (value is double)
{
return (double)value;
}
double num = ((!(value is BigInteger bigInteger)) ? Convert.ToDouble(value, CultureInfo.InvariantCulture) : ((double)bigInteger));
SetToken(JsonToken.Float, num, updateIndex: false);
return num;
}
case JsonToken.String:
return ReadDoubleString((string)Value);
default:
throw JsonReaderException.Create(this, "Error reading double. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal double? ReadDoubleString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (double.TryParse(s, NumberStyles.Float | NumberStyles.AllowThousands, Culture, out var result))
{
SetToken(JsonToken.Float, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to double: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual bool? ReadAsBoolean()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
bool flag = ((!(Value is BigInteger bigInteger)) ? Convert.ToBoolean(Value, CultureInfo.InvariantCulture) : (bigInteger != 0L));
SetToken(JsonToken.Boolean, flag, updateIndex: false);
return flag;
}
case JsonToken.String:
return ReadBooleanString((string)Value);
case JsonToken.Boolean:
return (bool)Value;
default:
throw JsonReaderException.Create(this, "Error reading boolean. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal bool? ReadBooleanString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (bool.TryParse(s, out var result))
{
SetToken(JsonToken.Boolean, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to boolean: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual decimal? ReadAsDecimal()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Integer:
case JsonToken.Float:
{
object value = Value;
if (value is decimal)
{
return (decimal)value;
}
decimal num;
if (value is BigInteger bigInteger)
{
num = (decimal)bigInteger;
}
else
{
try
{
num = Convert.ToDecimal(value, CultureInfo.InvariantCulture);
}
catch (Exception ex)
{
throw JsonReaderException.Create(this, "Could not convert to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, value), ex);
}
}
SetToken(JsonToken.Float, num, updateIndex: false);
return num;
}
case JsonToken.String:
return ReadDecimalString((string)Value);
default:
throw JsonReaderException.Create(this, "Error reading decimal. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal decimal? ReadDecimalString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (decimal.TryParse(s, NumberStyles.Number, Culture, out var result))
{
SetToken(JsonToken.Float, result, updateIndex: false);
return result;
}
if (ConvertUtils.DecimalTryParse(s.ToCharArray(), 0, s.Length, out result) == ParseResult.Success)
{
SetToken(JsonToken.Float, result, updateIndex: false);
return result;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to decimal: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual DateTime? ReadAsDateTime()
{
switch (GetContentToken())
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Date:
if (Value is DateTimeOffset dateTimeOffset)
{
SetToken(JsonToken.Date, dateTimeOffset.DateTime, updateIndex: false);
}
return (DateTime)Value;
case JsonToken.String:
return ReadDateTimeString((string)Value);
default:
throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, TokenType));
}
}
internal DateTime? ReadDateTimeString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (DateTimeUtils.TryParseDateTime(s, DateTimeZoneHandling, _dateFormatString, Culture, out var dt))
{
dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
if (DateTime.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
{
dt = DateTimeUtils.EnsureDateTime(dt, DateTimeZoneHandling);
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
throw JsonReaderException.Create(this, "Could not convert string to DateTime: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
public virtual DateTimeOffset? ReadAsDateTimeOffset()
{
JsonToken contentToken = GetContentToken();
switch (contentToken)
{
case JsonToken.None:
case JsonToken.Null:
case JsonToken.EndArray:
return null;
case JsonToken.Date:
if (Value is DateTime dateTime)
{
SetToken(JsonToken.Date, new DateTimeOffset(dateTime), updateIndex: false);
}
return (DateTimeOffset)Value;
case JsonToken.String:
{
string s = (string)Value;
return ReadDateTimeOffsetString(s);
}
default:
throw JsonReaderException.Create(this, "Error reading date. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, contentToken));
}
}
internal DateTimeOffset? ReadDateTimeOffsetString(string? s)
{
if (StringUtils.IsNullOrEmpty(s))
{
SetToken(JsonToken.Null, null, updateIndex: false);
return null;
}
if (DateTimeUtils.TryParseDateTimeOffset(s, _dateFormatString, Culture, out var dt))
{
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
if (DateTimeOffset.TryParse(s, Culture, DateTimeStyles.RoundtripKind, out dt))
{
SetToken(JsonToken.Date, dt, updateIndex: false);
return dt;
}
SetToken(JsonToken.String, s, updateIndex: false);
throw JsonReaderException.Create(this, "Could not convert string to DateTimeOffset: {0}.".FormatWith(CultureInfo.InvariantCulture, s));
}
internal void ReaderReadAndAssert()
{
if (!Read())
{
throw CreateUnexpectedEndException();
}
}
internal JsonReaderException CreateUnexpectedEndException()
{
return JsonReaderException.Create(this, "Unexpected end when reading JSON.");
}
internal void ReadIntoWrappedTypeObject()
{
ReaderReadAndAssert();
if (Value != null && Value.ToString() == "$type")
{
ReaderReadAndAssert();
if (Value != null && Value.ToString().StartsWith("System.Byte[]", StringComparison.Ordinal))
{
ReaderReadAndAssert();
if (Value.ToString() == "$value")
{
return;
}
}
}
throw JsonReaderException.Create(this, "Error reading bytes. Unexpected token: {0}.".FormatWith(CultureInfo.InvariantCulture, JsonToken.StartObject));
}
public void Skip()
{
if (TokenType == JsonToken.PropertyName)
{
Read();
}
if (JsonTokenUtils.IsStartToken(TokenType))
{
int depth = Depth;
while (Read() && depth < Depth)
{
}
}
}
protected void SetToken(JsonToken newToken)
{
SetToken(newToken, null, updateIndex: true);
}
protected void SetToken(JsonToken newToken, object? value)
{
SetToken(newToken, value, updateIndex: true);
}
protected void SetToken(JsonToken newToken, object? value, bool updateIndex)
{
_tokenType = newToken;
_value = value;
switch (newToken)
{
case JsonToken.StartObject:
_currentState = State.ObjectStart;
Push(JsonContainerType.Object);
break;
case JsonToken.StartArray:
_currentState = State.ArrayStart;
Push(JsonContainerType.Array);
break;
case JsonToken.StartConstructor:
_currentState = State.ConstructorStart;
Push(JsonContainerType.Constructor);
break;
case JsonToken.EndObject:
ValidateEnd(JsonToken.EndObject);
break;
case JsonToken.EndArray:
ValidateEnd(JsonToken.EndArray);
break;
case JsonToken.EndConstructor:
ValidateEnd(JsonToken.EndConstructor);
break;
case JsonToken.PropertyName:
_currentState = State.Property;
_currentPosition.PropertyName = (string)value;
break;
case JsonToken.Raw:
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.String:
case JsonToken.Boolean:
case JsonToken.Null:
case JsonToken.Undefined:
case JsonToken.Date:
case JsonToken.Bytes:
SetPostValueState(updateIndex);
break;
case JsonToken.Comment:
break;
}
}
internal void SetPostValueState(bool updateIndex)
{
if (Peek() != 0 || SupportMultipleContent)
{
_currentState = State.PostValue;
}
else
{
SetFinished();
}
if (updateIndex)
{
UpdateScopeWithFinishedValue();
}
}
private void UpdateScopeWithFinishedValue()
{
if (_currentPosition.HasIndex)
{
_currentPosition.Position++;
}
}
private void ValidateEnd(JsonToken endToken)
{
JsonContainerType jsonContainerType = Pop();
if (GetTypeForCloseToken(endToken) != jsonContainerType)
{
throw JsonReaderException.Create(this, "JsonToken {0} is not valid for closing JsonType {1}.".FormatWith(CultureInfo.InvariantCulture, endToken, jsonContainerType));
}
if (Peek() != 0 || SupportMultipleContent)
{
_currentState = State.PostValue;
}
else
{
SetFinished();
}
}
protected void SetStateBasedOnCurrent()
{
JsonContainerType jsonContainerType = Peek();
switch (jsonContainerType)
{
case JsonContainerType.Object:
_currentState = State.Object;
break;
case JsonContainerType.Array:
_currentState = State.Array;
break;
case JsonContainerType.Constructor:
_currentState = State.Constructor;
break;
case JsonContainerType.None:
SetFinished();
break;
default:
throw JsonReaderException.Create(this, "While setting the reader state back to current object an unexpected JsonType was encountered: {0}".FormatWith(CultureInfo.InvariantCulture, jsonContainerType));
}
}
private void SetFinished()
{
_currentState = ((!SupportMultipleContent) ? State.Finished : State.Start);
}
private JsonContainerType GetTypeForCloseToken(JsonToken token)
{
return token switch
{
JsonToken.EndObject => JsonContainerType.Object,
JsonToken.EndArray => JsonContainerType.Array,
JsonToken.EndConstructor => JsonContainerType.Constructor,
_ => throw JsonReaderException.Create(this, "Not a valid close JsonToken: {0}".FormatWith(CultureInfo.InvariantCulture, token)),
};
}
void IDisposable.Dispose()
{
Dispose(disposing: true);
GC.SuppressFinalize(this);
}
protected virtual void Dispose(bool disposing)
{
if (_currentState != State.Closed && disposing)
{
Close();
}
}
public virtual void Close()
{
_currentState = State.Closed;
_tokenType = JsonToken.None;
_value = null;
}
internal void ReadAndAssert()
{
if (!Read())
{
throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
}
}
internal void ReadForTypeAndAssert(JsonContract? contract, bool hasConverter)
{
if (!ReadForType(contract, hasConverter))
{
throw JsonSerializationException.Create(this, "Unexpected end when reading JSON.");
}
}
internal bool ReadForType(JsonContract? contract, bool hasConverter)
{
if (hasConverter)
{
return Read();
}
switch (contract?.InternalReadType ?? ReadType.Read)
{
case ReadType.Read:
return ReadAndMoveToContent();
case ReadType.ReadAsInt32:
ReadAsInt32();
break;
case ReadType.ReadAsInt64:
{
bool result = ReadAndMoveToContent();
if (TokenType == JsonToken.Undefined)
{
throw JsonReaderException.Create(this, "An undefined token is not a valid {0}.".FormatWith(CultureInfo.InvariantCulture, contract?.UnderlyingType ?? typeof(long)));
}
return result;
}
case ReadType.ReadAsDecimal:
ReadAsDecimal();
break;
case ReadType.ReadAsDouble:
ReadAsDouble();
break;
case ReadType.ReadAsBytes:
ReadAsBytes();
break;
case ReadType.ReadAsBoolean:
ReadAsBoolean();
break;
case ReadType.ReadAsString:
ReadAsString();
break;
case ReadType.ReadAsDateTime:
ReadAsDateTime();
break;
case ReadType.ReadAsDateTimeOffset:
ReadAsDateTimeOffset();
break;
default:
throw new ArgumentOutOfRangeException();
}
return TokenType != JsonToken.None;
}
internal bool ReadAndMoveToContent()
{
if (Read())
{
return MoveToContent();
}
return false;
}
internal bool MoveToContent()
{
JsonToken tokenType = TokenType;
while (tokenType == JsonToken.None || tokenType == JsonToken.Comment)
{
if (!Read())
{
return false;
}
tokenType = TokenType;
}
return true;
}
private JsonToken GetContentToken()
{
JsonToken tokenType;
do
{
if (!Read())
{
SetToken(JsonToken.None);
return JsonToken.None;
}
tokenType = TokenType;
}
while (tokenType == JsonToken.Comment);
return tokenType;
}
}
[Serializable]
public class JsonReaderException : JsonException
{
public int LineNumber { get; }
public int LinePosition { get; }
public string? Path { get; }
public JsonReaderException()
{
}
public JsonReaderException(string message)
: base(message)
{
}
public JsonReaderException(string message, Exception innerException)
: base(message, innerException)
{
}
public JsonReaderException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
public JsonReaderException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
: base(message, innerException)
{
Path = path;
LineNumber = lineNumber;
LinePosition = linePosition;
}
internal static JsonReaderException Create(JsonReader reader, string message)
{
return Create(reader, message, null);
}
internal static JsonReaderException Create(JsonReader reader, string message, Exception? ex)
{
return Create(reader as IJsonLineInfo, reader.Path, message, ex);
}
internal static JsonReaderException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
int lineNumber;
int linePosition;
if (lineInfo != null && lineInfo.HasLineInfo())
{
lineNumber = lineInfo.LineNumber;
linePosition = lineInfo.LinePosition;
}
else
{
lineNumber = 0;
linePosition = 0;
}
return new JsonReaderException(message, path, lineNumber, linePosition, ex);
}
}
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
public sealed class JsonRequiredAttribute : Attribute
{
}
[Serializable]
public class JsonSerializationException : JsonException
{
public int LineNumber { get; }
public int LinePosition { get; }
public string? Path { get; }
public JsonSerializationException()
{
}
public JsonSerializationException(string message)
: base(message)
{
}
public JsonSerializationException(string message, Exception innerException)
: base(message, innerException)
{
}
public JsonSerializationException(SerializationInfo info, StreamingContext context)
: base(info, context)
{
}
public JsonSerializationException(string message, string path, int lineNumber, int linePosition, Exception? innerException)
: base(message, innerException)
{
Path = path;
LineNumber = lineNumber;
LinePosition = linePosition;
}
internal static JsonSerializationException Create(JsonReader reader, string message)
{
return Create(reader, message, null);
}
internal static JsonSerializationException Create(JsonReader reader, string message, Exception? ex)
{
return Create(reader as IJsonLineInfo, reader.Path, message, ex);
}
internal static JsonSerializationException Create(IJsonLineInfo? lineInfo, string path, string message, Exception? ex)
{
message = JsonPosition.FormatMessage(lineInfo, path, message);
int lineNumber;
int linePosition;
if (lineInfo != null && lineInfo.HasLineInfo())
{
lineNumber = lineInfo.LineNumber;
linePosition = lineInfo.LinePosition;
}
else
{
lineNumber = 0;
linePosition = 0;
}
return new JsonSerializationException(message, path, lineNumber, linePosition, ex);
}
}
public class JsonSerializer
{
internal TypeNameHandling _typeNameHandling;
internal TypeNameAssemblyFormatHandling _typeNameAssemblyFormatHandling;
internal PreserveReferencesHandling _preserveReferencesHandling;
internal ReferenceLoopHandling _referenceLoopHandling;
internal MissingMemberHandling _missingMemberHandling;
internal ObjectCreationHandling _objectCreationHandling;
internal NullValueHandling _nullValueHandling;
internal DefaultValueHandling _defaultValueHandling;
internal ConstructorHandling _constructorHandling;
internal MetadataPropertyHandling _metadataPropertyHandling;
internal JsonConverterCollection? _converters;
internal IContractResolver _contractResolver;
internal ITraceWriter? _traceWriter;
internal IEqualityComparer? _equalityComparer;
internal ISerializationBinder _serializationBinder;
internal StreamingContext _context;
private IReferenceResolver? _referenceResolver;
private Formatting? _formatting;
private DateFormatHandling? _dateFormatHandling;
private DateTimeZoneHandling? _dateTimeZoneHandling;
private DateParseHandling? _dateParseHandling;
private FloatFormatHandling? _floatFormatHandling;
private FloatParseHandling? _floatParseHandling;
private StringEscapeHandling? _stringEscapeHandling;
private CultureInfo _culture;
private int? _maxDepth;
private bool _maxDepthSet;
private bool? _checkAdditionalContent;
private string? _dateFormatString;
private bool _dateFormatStringSet;
public virtual IReferenceResolver? ReferenceResolver
{
get
{
return GetReferenceResolver();
}
set
{
if (value == null)
{
throw new ArgumentNullException("value", "Reference resolver cannot be null.");
}
_referenceResolver = value;
}
}
[Obsolete("Binder is obsolete. Use SerializationBinder instead.")]
public virtual SerializationBinder Binder
{
get
{
if (_serializationBinder is SerializationBinder result)
{
return result;
}
if (_serializationBinder is SerializationBinderAdapter serializationBinderAdapter)
{
return serializationBinderAdapter.SerializationBinder;
}
throw new InvalidOperationException("Cannot get SerializationBinder because an ISerializationBinder was previously set.");
}
set
{
if (value == null)
{
throw new ArgumentNullException("value", "Serialization binder cannot be null.");
}
_serializationBinder = (value as ISerializationBinder) ?? new SerializationBinderAdapter(value);
}
}
public virtual ISerializationBinder SerializationBinder
{
get
{
return _serializationBinder;
}
set
{
if (value == null)
{
throw new ArgumentNullException("value", "Serialization binder cannot be null.");
}
_serializationBinder = value;
}
}
public virtual ITraceWriter? TraceWriter
{
get
{
return _traceWriter;
}
set
{
_traceWriter = value;
}
}
public virtual IEqualityComparer? EqualityComparer
{
get
{
return _equalityComparer;
}
set
{
_equalityComparer = value;
}
}
public virtual TypeNameHandling TypeNameHandling
{
get
{
return _typeNameHandling;
}
set
{
if (value < TypeNameHandling.None || value > TypeNameHandling.Auto)
{
throw new ArgumentOutOfRangeException("value");
}
_typeNameHandling = value;
}
}
[Obsolete("TypeNameAssemblyFormat is obsolete. Use TypeNameAssemblyFormatHandling instead.")]
public virtual FormatterAssemblyStyle TypeNameAssemblyFormat
{
get
{
return (FormatterAssemblyStyle)_typeNameAssemblyFormatHandling;
}
set
{
if (value < FormatterAssemblyStyle.Simple || value > FormatterAssemblyStyle.Full)
{
throw new ArgumentOutOfRangeException("value");
}
_typeNameAssemblyFormatHandling = (TypeNameAssemblyFormatHandling)value;
}
}
public virtual TypeNameAssemblyFormatHandling TypeNameAssemblyFormatHandling
{
get
{
return _typeNameAssemblyFormatHandling;
}
set
{
if (value < TypeNameAssemblyFormatHandling.Simple || value > TypeNameAssemblyFormatHandling.Full)
{
throw new ArgumentOutOfRangeException("value");
}
_typeNameAssemblyFormatHandling = value;
}
}
public virtual PreserveReferencesHandling PreserveReferencesHandling
{
get
{
return _preserveReferencesHandling;
}
set
{
if (value < PreserveReferencesHandling.None || value > PreserveReferencesHandling.All)
{
throw new ArgumentOutOfRangeException("value");
}
_preserveReferencesHandling = value;
}
}
public virtual ReferenceLoopHandling ReferenceLoopHandling
{
get
{
return _referenceLoopHandling;
}
set
{
if (value < ReferenceLoopHandling.Error || value > ReferenceLoopHandling.Serialize)
{
throw new ArgumentOutOfRangeException("value");
}
_referenceLoopHandling = value;
}
}
public virtual MissingMemberHandling MissingMemberHandling
{
get
{
return _missingMemberHandling;
}
set
{
if (value < MissingMemberHandling.Ignore || value > MissingMemberHandling.Error)
{
throw new ArgumentOutOfRangeException("value");
}
_missingMemberHandling = value;
}
}
public virtual NullValueHandling NullValueHandling
{
get
{
return _nullValueHandling;
}
set
{
if (value < NullValueHandling.Include || value > NullValueHandling.Ignore)
{
throw new ArgumentOutOfRangeException("value");
}
_nullValueHandling = value;
}
}
public virtual DefaultValueHandling DefaultValueHandling
{
get
{
return _defaultValueHandling;
}
set
{
if (value < DefaultValueHandling.Include || value > DefaultValueHandling.IgnoreAndPopulate)
{
throw new ArgumentOutOfRangeException("value");
}
_defaultValueHandling = value;
}
}
public virtual ObjectCreationHandling ObjectCreationHandling
{
get
{
return _objectCreationHandling;
}
set
{
if (value < ObjectCreationHandling.Auto || value > ObjectCreationHandling.Replace)
{
throw new ArgumentOutOfRangeException("value");
}
_objectCreationHandling = value;
}
}
public virtual ConstructorHandling ConstructorHandling
{
get
{
return _constructorHandling;
}
set
{
if (value < ConstructorHandling.Default || value > ConstructorHandling.AllowNonPublicDefaultConstructor)
{
throw new ArgumentOutOfRangeException("value");
}
_constructorHandling = value;
}
}
public virtual MetadataPropertyHandling MetadataPropertyHandling
{
get
{
return _metadataPropertyHandling;
}
set
{
if (value < MetadataPropertyHandling.Default || value > MetadataPropertyHandling.Ignore)
{
throw new ArgumentOutOfRangeException("value");
}
_metadataPropertyHandling = value;
}
}
public virtual JsonConverterCollection Converters
{
get
{
if (_converters == null)
{
_converters = new JsonConverterCollection();
}
return _converters;
}
}
public virtual IContractResolver ContractResolver
{
get
{
return _contractResolver;
}
set
{
_contractResolver = value ?? DefaultContractResolver.Instance;
}
}
public virtual StreamingContext Context
{
get
{
return _context;
}
set
{
_context = value;
}
}
public virtual Formatting Formatting
{
get
{
return _formatting.GetValueOrDefault();
}
set
{
_formatting = value;
}
}
public virtual DateFormatHandling DateFormatHandling
{
get
{
return _dateFormatHandling.GetValueOrDefault();
}
set
{
_dateFormatHandling = value;
}
}
public virtual DateTimeZoneHandling DateTimeZoneHandling
{
get
{
return _dateTimeZoneHandling ?? DateTimeZoneHandling.RoundtripKind;
}
set
{
_dateTimeZoneHandling = value;
}
}
public virtual DateParseHandling DateParseHandling
{
get
{
return _dateParseHandling ?? DateParseHandling.DateTime;
}
set
{
_dateParseHandling = value;
}
}
public virtual FloatParseHandling FloatParseHandling
{
get
{
return _floatParseHandling.GetValueOrDefault();
}
set
{
_floatParseHandling = value;
}
}
public virtual FloatFormatHandling FloatFormatHandling
{
get
{
return _floatFormatHandling.GetValueOrDefault();
}
set
{
_floatFormatHandling = value;
}
}
public virtual StringEscapeHandling StringEscapeHandling
{
get
{
return _stringEscapeHandling.GetValueOrDefault();
}
set
{
_stringEscapeHandling = value;
}
}
public virtual string DateFormatString
{
get
{
return _dateFormatString ?? "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
}
set
{
_dateFormatString = value;
_dateFormatStringSet = true;
}
}
public virtual CultureInfo Culture
{
get
{
return _culture ?? JsonSerializerSettings.DefaultCulture;
}
set
{
_culture = value;
}
}
public virtual int? MaxDepth
{
get
{
return _maxDepth;
}
set
{
if (value <= 0)
{
throw new ArgumentException("Value must be positive.", "value");
}
_maxDepth = value;
_maxDepthSet = true;
}
}
public virtual bool CheckAdditionalContent
{
get
{
return _checkAdditionalContent.GetValueOrDefault();
}
set
{
_checkAdditionalContent = value;
}
}
public virtual event EventHandler<Newtonsoft.Json.Serialization.ErrorEventArgs>? Error;
internal bool IsCheckAdditionalContentSet()
{
return _checkAdditionalContent.HasValue;
}
public JsonSerializer()
{
_referenceLoopHandling = ReferenceLoopHandling.Error;
_missingMemberHandling = MissingMemberHandling.Ignore;
_nullValueHandling = NullValueHandling.Include;
_defaultValueHandling = DefaultValueHandling.Include;
_objectCreationHandling = ObjectCreationHandling.Auto;
_preserveReferencesHandling = PreserveReferencesHandling.None;
_constructorHandling = ConstructorHandling.Default;
_typeNameHandling = TypeNameHandling.None;
_metadataPropertyHandling = MetadataPropertyHandling.Default;
_context = JsonSerializerSettings.DefaultContext;
_serializationBinder = DefaultSerializationBinder.Instance;
_culture = JsonSerializerSettings.DefaultCulture;
_contractResolver = DefaultContractResolver.Instance;
}
public static JsonSerializer Create()
{
return new JsonSerializer();
}
public static JsonSerializer Create(JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = Create();
if (settings != null)
{
ApplySerializerSettings(jsonSerializer, settings);
}
return jsonSerializer;
}
public static JsonSerializer CreateDefault()
{
return Create(JsonConvert.DefaultSettings?.Invoke());
}
public static JsonSerializer CreateDefault(JsonSerializerSettings? settings)
{
JsonSerializer jsonSerializer = CreateDefault();
if (settings != null)
{
ApplySerializerSettings(jsonSerializer, settings);
}
return jsonSerializer;
}
private static void ApplySerializerSettings(JsonSerializer serializer, JsonSerializerSettings settings)
{
if (!CollectionUtils.IsNullOrEmpty(settings.Converters))
{
for (int i = 0; i < settings.Converters.Count; i++)
{
serializer.Converters.Insert(i, settings.Converters[i]);
}
}
if (settings._typeNameHandling.HasValue)
{
serializer.TypeNameHandling = settings.TypeNameHandling;
}
if (settings._metadataPropertyHandling.HasValue)
{
serializer.MetadataPropertyHandling = settings.MetadataPropertyHandling;
}
if (settings._typeNameAssemblyFormatHandling.HasValue)
{
serializer.TypeNameAssemblyFormatHandling = settings.TypeNameAssemblyFormatHandling;
}
if (settings._preserveReferencesHandling.HasValue)
{
serializer.PreserveReferencesHandling = settings.PreserveReferencesHandling;
}
if (settings._referenceLoopHandling.HasValue)
{
serializer.ReferenceLoopHandling = settings.ReferenceLoopHandling;
}
if (settings._missingMemberHandling.HasValue)
{
serializer.MissingMemberHandling = settings.MissingMemberHandling;
}
if (settings._objectCreationHandling.HasValue)
{
serializer.ObjectCreationHandling = settings.ObjectCreationHandling;
}
if (settings._nullValueHandling.HasValue)
{
serializer.NullValueHandling = settings.NullValueHandling;
}
if (settings._defaultValueHandling.HasValue)
{
serializer.DefaultValueHandling = settings.DefaultValueHandling;
}
if (settings._constructorHandling.HasValue)
{
serializer.ConstructorHandling = settings.ConstructorHandling;
}
if (settings._context.HasValue)
{
serializer.Context = settings.Context;
}
if (settings._checkAdditionalContent.HasValue)
{
serializer._checkAdditionalContent = settings._checkAdditionalContent;
}
if (settings.Error != null)
{
serializer.Error += settings.Error;
}
if (settings.ContractResolver != null)
{
serializer.ContractResolver = settings.ContractResolver;
}
if (settings.ReferenceResolverProvider != null)
{
serializer.ReferenceResolver = settings.ReferenceResolverProvider();
}
if (settings.TraceWriter != null)
{
serializer.TraceWriter = settings.TraceWriter;
}
if (settings.EqualityComparer != null)
{
serializer.EqualityComparer = settings.EqualityComparer;
}
if (settings.SerializationBinder != null)
{
serializer.SerializationBinder = settings.SerializationBinder;
}
if (settings._formatting.HasValue)
{
serializer._formatting = settings._formatting;
}
if (settings._dateFormatHandling.HasValue)
{
serializer._dateFormatHandling = settings._dateFormatHandling;
}
if (settings._dateTimeZoneHandling.HasValue)
{
serializer._dateTimeZoneHandling = settings._dateTimeZoneHandling;
}
if (settings._dateParseHandling.HasValue)
{
serializer._dateParseHandling = settings._dateParseHandling;
}
if (settings._dateFormatStringSet)
{
serializer._dateFormatString = settings._dateFormatString;
serializer._dateFormatStringSet = settings._dateFormatStringSet;
}
if (settings._floatFormatHandling.HasValue)
{
serializer._floatFormatHandling = settings._floatFormatHandling;
}
if (settings._floatParseHandling.HasValue)
{
serializer._floatParseHandling = settings._floatParseHandling;
}
if (settings._stringEscapeHandling.HasValue)
{
serializer._stringEscapeHandling = settings._stringEscapeHandling;
}
if (settings._culture != null)
{
serializer._culture = settings._culture;
}
if (settings._maxDepthSet)
{
serializer._maxDepth = settings._maxDepth;
serializer._maxDepthSet = settings._maxDepthSet;
}
}
[DebuggerStepThrough]
public void Populate(TextReader reader, object target)
{
Populate(new JsonTextReader(reader), target);
}
[DebuggerStepThrough]
public void Populate(JsonReader reader, object target)
{
PopulateInternal(reader, target);
}
internal virtual void PopulateInternal(JsonReader reader, object target)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
ValidationUtils.ArgumentNotNull(target, "target");
SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString);
TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null);
new JsonSerializerInternalReader(this).Populate(traceJsonReader ?? reader, target);
if (traceJsonReader != null)
{
TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
}
ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
}
[DebuggerStepThrough]
public object? Deserialize(JsonReader reader)
{
return Deserialize(reader, null);
}
[DebuggerStepThrough]
public object? Deserialize(TextReader reader, Type objectType)
{
return Deserialize(new JsonTextReader(reader), objectType);
}
[DebuggerStepThrough]
public T? Deserialize<T>(JsonReader reader)
{
return (T)Deserialize(reader, typeof(T));
}
[DebuggerStepThrough]
public object? Deserialize(JsonReader reader, Type? objectType)
{
return DeserializeInternal(reader, objectType);
}
internal virtual object? DeserializeInternal(JsonReader reader, Type? objectType)
{
ValidationUtils.ArgumentNotNull(reader, "reader");
SetupReader(reader, out CultureInfo previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string previousDateFormatString);
TraceJsonReader traceJsonReader = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? CreateTraceJsonReader(reader) : null);
object? result = new JsonSerializerInternalReader(this).Deserialize(traceJsonReader ?? reader, objectType, CheckAdditionalContent);
if (traceJsonReader != null)
{
TraceWriter.Trace(TraceLevel.Verbose, traceJsonReader.GetDeserializedJsonMessage(), null);
}
ResetReader(reader, previousCulture, previousDateTimeZoneHandling, previousDateParseHandling, previousFloatParseHandling, previousMaxDepth, previousDateFormatString);
return result;
}
internal void SetupReader(JsonReader reader, out CultureInfo? previousCulture, out DateTimeZoneHandling? previousDateTimeZoneHandling, out DateParseHandling? previousDateParseHandling, out FloatParseHandling? previousFloatParseHandling, out int? previousMaxDepth, out string? previousDateFormatString)
{
if (_culture != null && !_culture.Equals(reader.Culture))
{
previousCulture = reader.Culture;
reader.Culture = _culture;
}
else
{
previousCulture = null;
}
if (_dateTimeZoneHandling.HasValue && reader.DateTimeZoneHandling != _dateTimeZoneHandling)
{
previousDateTimeZoneHandling = reader.DateTimeZoneHandling;
reader.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
}
else
{
previousDateTimeZoneHandling = null;
}
if (_dateParseHandling.HasValue && reader.DateParseHandling != _dateParseHandling)
{
previousDateParseHandling = reader.DateParseHandling;
reader.DateParseHandling = _dateParseHandling.GetValueOrDefault();
}
else
{
previousDateParseHandling = null;
}
if (_floatParseHandling.HasValue && reader.FloatParseHandling != _floatParseHandling)
{
previousFloatParseHandling = reader.FloatParseHandling;
reader.FloatParseHandling = _floatParseHandling.GetValueOrDefault();
}
else
{
previousFloatParseHandling = null;
}
if (_maxDepthSet && reader.MaxDepth != _maxDepth)
{
previousMaxDepth = reader.MaxDepth;
reader.MaxDepth = _maxDepth;
}
else
{
previousMaxDepth = null;
}
if (_dateFormatStringSet && reader.DateFormatString != _dateFormatString)
{
previousDateFormatString = reader.DateFormatString;
reader.DateFormatString = _dateFormatString;
}
else
{
previousDateFormatString = null;
}
if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable == null && _contractResolver is DefaultContractResolver defaultContractResolver)
{
jsonTextReader.PropertyNameTable = defaultContractResolver.GetNameTable();
}
}
private void ResetReader(JsonReader reader, CultureInfo? previousCulture, DateTimeZoneHandling? previousDateTimeZoneHandling, DateParseHandling? previousDateParseHandling, FloatParseHandling? previousFloatParseHandling, int? previousMaxDepth, string? previousDateFormatString)
{
if (previousCulture != null)
{
reader.Culture = previousCulture;
}
if (previousDateTimeZoneHandling.HasValue)
{
reader.DateTimeZoneHandling = previousDateTimeZoneHandling.GetValueOrDefault();
}
if (previousDateParseHandling.HasValue)
{
reader.DateParseHandling = previousDateParseHandling.GetValueOrDefault();
}
if (previousFloatParseHandling.HasValue)
{
reader.FloatParseHandling = previousFloatParseHandling.GetValueOrDefault();
}
if (_maxDepthSet)
{
reader.MaxDepth = previousMaxDepth;
}
if (_dateFormatStringSet)
{
reader.DateFormatString = previousDateFormatString;
}
if (reader is JsonTextReader jsonTextReader && jsonTextReader.PropertyNameTable != null && _contractResolver is DefaultContractResolver defaultContractResolver && jsonTextReader.PropertyNameTable == defaultContractResolver.GetNameTable())
{
jsonTextReader.PropertyNameTable = null;
}
}
public void Serialize(TextWriter textWriter, object? value)
{
Serialize(new JsonTextWriter(textWriter), value);
}
public void Serialize(JsonWriter jsonWriter, object? value, Type? objectType)
{
SerializeInternal(jsonWriter, value, objectType);
}
public void Serialize(TextWriter textWriter, object? value, Type objectType)
{
Serialize(new JsonTextWriter(textWriter), value, objectType);
}
public void Serialize(JsonWriter jsonWriter, object? value)
{
SerializeInternal(jsonWriter, value, null);
}
private TraceJsonReader CreateTraceJsonReader(JsonReader reader)
{
TraceJsonReader traceJsonReader = new TraceJsonReader(reader);
if (reader.TokenType != 0)
{
traceJsonReader.WriteCurrentToken();
}
return traceJsonReader;
}
internal virtual void SerializeInternal(JsonWriter jsonWriter, object? value, Type? objectType)
{
ValidationUtils.ArgumentNotNull(jsonWriter, "jsonWriter");
Formatting? formatting = null;
if (_formatting.HasValue && jsonWriter.Formatting != _formatting)
{
formatting = jsonWriter.Formatting;
jsonWriter.Formatting = _formatting.GetValueOrDefault();
}
DateFormatHandling? dateFormatHandling = null;
if (_dateFormatHandling.HasValue && jsonWriter.DateFormatHandling != _dateFormatHandling)
{
dateFormatHandling = jsonWriter.DateFormatHandling;
jsonWriter.DateFormatHandling = _dateFormatHandling.GetValueOrDefault();
}
DateTimeZoneHandling? dateTimeZoneHandling = null;
if (_dateTimeZoneHandling.HasValue && jsonWriter.DateTimeZoneHandling != _dateTimeZoneHandling)
{
dateTimeZoneHandling = jsonWriter.DateTimeZoneHandling;
jsonWriter.DateTimeZoneHandling = _dateTimeZoneHandling.GetValueOrDefault();
}
FloatFormatHandling? floatFormatHandling = null;
if (_floatFormatHandling.HasValue && jsonWriter.FloatFormatHandling != _floatFormatHandling)
{
floatFormatHandling = jsonWriter.FloatFormatHandling;
jsonWriter.FloatFormatHandling = _floatFormatHandling.GetValueOrDefault();
}
StringEscapeHandling? stringEscapeHandling = null;
if (_stringEscapeHandling.HasValue && jsonWriter.StringEscapeHandling != _stringEscapeHandling)
{
stringEscapeHandling = jsonWriter.StringEscapeHandling;
jsonWriter.StringEscapeHandling = _stringEscapeHandling.GetValueOrDefault();
}
CultureInfo cultureInfo = null;
if (_culture != null && !_culture.Equals(jsonWriter.Culture))
{
cultureInfo = jsonWriter.Culture;
jsonWriter.Culture = _culture;
}
string dateFormatString = null;
if (_dateFormatStringSet && jsonWriter.DateFormatString != _dateFormatString)
{
dateFormatString = jsonWriter.DateFormatString;
jsonWriter.DateFormatString = _dateFormatString;
}
TraceJsonWriter traceJsonWriter = ((TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose) ? new TraceJsonWriter(jsonWriter) : null);
new JsonSerializerInternalWriter(this).Serialize(traceJsonWriter ?? jsonWriter, value, objectType);
if (traceJsonWriter != null)
{
TraceWriter.Trace(TraceLevel.Verbose, traceJsonWriter.GetSerializedJsonMessage(), null);
}
if (formatting.HasValue)
{
jsonWriter.Formatting = formatting.GetValueOrDefault();
}
if (dateFormatHandling.HasValue)
{
jsonWriter.DateFormatHandling = dateFormatHandling.GetValueOrDefault();
}
if (dateTimeZoneHandling.HasValue)
{
jsonWriter.DateTimeZoneHandling = dateTimeZoneHandling.GetValueOrDefault();
}
if (floatFormatHandling.HasValue)
{
jsonWriter.FloatFormatHandling = floatFormatHandling.GetValueOrDefault();
}
if (stringEscapeHandling.HasValue)
{
jsonWriter.StringEscapeHandling = stringEscapeHandling.GetValueOrDefault();
}
if (_dateFormatStringSet)
{
jsonWriter.DateFormatString = dateFormatString;
}
if (cultureInfo != null)
{
jsonWriter.Culture = cultureInfo;
}
}
internal IReferenceResolver GetReferenceResolver()
{
if (_referenceResolver == null)
{
_referenceResolver = new DefaultReferenceResolver();
}
return _referenceResolver;
}
internal JsonConverter? GetMatchingConverter(Type type)
{
return GetMatchingConverter(_converters, type);
}
internal static JsonConverter? GetMatchingConverter(IList<JsonConverter>? converters, Type objectType)
{
if (converters != null)
{
for (int i = 0; i < converters.Count; i++)
{
JsonConverter jsonConverter = converters[i];
if (jsonConverter.CanConvert(objectType))
{
return jsonConverter;
}
}
}
return null;
}
internal void OnError(Newtonsoft.Json.Serialization.ErrorEventArgs e)
{
this.Error?.Invoke(this, e);
}
}
public class JsonSerializerSettings
{
internal const ReferenceLoopHandling DefaultReferenceLoopHandling = ReferenceLoopHandling.Error;
internal const MissingMemberHandling DefaultMissingMemberHandling = MissingMemberHandling.Ignore;
internal const NullValueHandling DefaultNullValueHandling = NullValueHandling.Include;
internal const DefaultValueHandling DefaultDefaultValueHandling = DefaultValueHandling.Include;
internal const ObjectCreationHandling DefaultObjectCreationHandling = ObjectCreationHandling.Auto;
internal const PreserveReferencesHandling DefaultPreserveReferencesHandling = PreserveReferencesHandling.None;
internal const ConstructorHandling DefaultConstructorHandling = ConstructorHandling.Default;
internal const TypeNameHandling DefaultTypeNameHandling = TypeNameHandling.None;
internal const MetadataPropertyHandling DefaultMetadataPropertyHandling = MetadataPropertyHandling.Default;
internal static readonly StreamingContext DefaultContext;
internal const Formatting DefaultFormatting = Formatting.None;
internal const DateFormatHandling DefaultDateFormatHandling = DateFormatHandling.IsoDateFormat;
internal const DateTimeZoneHandling DefaultDateTimeZoneHandling = DateTimeZoneHandling.RoundtripKind;
internal const DateParseHandling DefaultDateParseHandling = DateParseHandling.DateTime;
internal const FloatParseHandling DefaultFloatParseHandling = FloatParseHandling.Double;
internal const FloatFormatHandling DefaultFloatFormatHandling = FloatFormatHandling.String;
internal const StringEscapeHandling DefaultStringEscapeHandling = StringEscapeHandling.Default;
internal const TypeNameAssemblyFormatHandling DefaultTypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Simple;
internal static readonly CultureInfo DefaultCulture;
internal const bool DefaultCheckAdditionalContent = false;
internal const string DefaultDateFormatString = "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK";
internal const int DefaultMaxDepth = 64;
internal Formatting? _formatting;
internal DateFormatHandling? _dateFormatHandling;
internal DateTimeZoneHandling? _dateTimeZoneHandling;
internal DateParseHandling? _dateParseHandling;
internal FloatFormatHandling? _floatFormatHandling;
internal FloatParseHandling? _floatParseHandling;
internal StringEscapeHandling? _stringEscapeHandling;
internal CultureInfo? _culture;
internal bool? _checkAdditionalContent;
internal int? _maxDepth;
internal bool _maxDepthSet;
internal string? _dateFormatString;
internal bool _dateFormatStringSet;
internal TypeNameAssemblyFormatHandling? _typeNameAssemblyFormatHandling;
internal DefaultValueHandling? _defaultValueHandling;
internal PreserveReferencesHandling? _preserveReferencesHandling;
internal NullValueHandling? _nullValueHandling;
internal ObjectCreationHandling? _objectCreationHandling;
internal MissingMemberHandling? _missingMemberHandling;
internal ReferenceLoopHandling? _referenceLoopHandling;
internal StreamingContext? _context;
internal ConstructorHandling? _constructorHandling;
internal TypeNameHandling? _typeNameHandling;
internal MetadataPropertyHandling? _metadataPropertyHandling;
public ReferenceLoopHandling ReferenceLoopHandling
{
get
{
return _referenceLoopHandling.GetValueOrDefault();
}
set
{
_referenceLoopHandling = value;
}
}
public MissingMemberHandling MissingMemberHandling
{
get
{
return _missingMemberHandling.GetValueOrDefault();
}
set
{
_missingMemberHandling = value;
}
}
public ObjectCreationHandling ObjectCreationHandling
{
get
{
return _objectCreationHandling.GetValueOrDefault();
}
set
{
_objectCreationHandling = value;
}
}
public NullValueHandling NullValueHandling
{
get
{
return _nullValueHandling.GetValueOrDefault();
}
set
{
_nullValueHandling = value;
}
}
public DefaultValueHandling DefaultValueHandling
{
get
{
return _defaultValueHandling.GetValueOrDefault();
}
set
{
_defaultValueHandling = value;
}
}
public IList<JsonConverter> Converters { get; set; }
public PreserveReferencesHandling PreserveReferencesHandling
{
get
{
return _preserveReferencesHandling.GetValueOrDefault();
}
set
{
_preserveReferencesHandling = value;
}
}
public TypeNameHandling TypeNameHandling
{
get
{
return _typeNameHandling.GetValueOrDefault();
}
set
{