using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Logging;
using Microsoft.CodeAnalysis;
using R2API.AutoVersionGen;
using R2API.Networking.Interfaces;
using R2API.Networking.Messages;
using R2API.Utils;
using RoR2;
using RoR2.Networking;
using UnityEngine;
using UnityEngine.Networking;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("R2API.Networking")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.4.0")]
[assembly: AssemblyInformationalVersion("1.0.4+72fb4acded8caa7a86ab495cc2762c4ae961b47b")]
[assembly: AssemblyProduct("R2API.Networking")]
[assembly: AssemblyTitle("R2API.Networking")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.4.0")]
[assembly: TypeForwardedTo(typeof(CompatibilityLevel))]
[assembly: TypeForwardedTo(typeof(NetworkCompatibility))]
[assembly: TypeForwardedTo(typeof(VersionStrictness))]
[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.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;
		}
	}
	[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 System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
}
namespace R2API.AutoVersionGen
{
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = false)]
	internal class AutoVersionAttribute : Attribute
	{
	}
}
namespace R2API.Networking
{
	internal class Header : ISerializableObject
	{
		internal int TypeCode { get; private set; }

		internal NetworkDestination Destination { get; private set; }

		public Header()
		{
		}

		internal Header(int typeCode, NetworkDestination dest)
		{
			TypeCode = typeCode;
			Destination = dest;
		}

		internal void RemoveDestination(NetworkDestination destination)
		{
			Destination &= (NetworkDestination)(byte)(~(int)destination);
		}

		public void Serialize(NetworkWriter writer)
		{
			writer.Write(TypeCode);
			writer.Write((byte)Destination);
		}

		public void Deserialize(NetworkReader reader)
		{
			TypeCode = reader.ReadInt32();
			Destination = (NetworkDestination)reader.ReadByte();
		}
	}
	[Flags]
	public enum NetworkDestination : byte
	{
		Clients = 1,
		Server = 2
	}
	internal static class NetworkDestinationExtensions
	{
		internal static bool ShouldSend(this NetworkDestination dest)
		{
			if (NetworkServer.active)
			{
				return dest != NetworkDestination.Server;
			}
			return true;
		}

		internal static bool ShouldRun(this NetworkDestination dest)
		{
			bool active = NetworkServer.active;
			bool active2 = NetworkClient.active;
			if (!active || (dest & NetworkDestination.Server) == 0)
			{
				if (active2)
				{
					return (dest & NetworkDestination.Clients) != 0;
				}
				return false;
			}
			return true;
		}

		internal static Header GetHeader(this NetworkDestination dest, int typeCode)
		{
			return new Header(typeCode, dest);
		}
	}
	[AutoVersion]
	public static class NetworkingAPI
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static Action <0>__RegisterServerHandlers;

			public static Action<NetworkClient> <1>__RegisterClientHandlers;

			public static Action <2>__UnRegisterServerHandlers;

			public static Action <3>__UnRegisterClientHandlers;

			public static NetworkMessageDelegate <4>__HandleMessageServer;

			public static NetworkMessageDelegate <5>__HandleCommandServer;

			public static NetworkMessageDelegate <6>__HandleRequestServer;

			public static NetworkMessageDelegate <7>__HandleReplyServer;

			public static NetworkMessageDelegate <8>__HandleMessageClient;

			public static NetworkMessageDelegate <9>__HandleCommandClient;

			public static NetworkMessageDelegate <10>__HandleRequestClient;

			public static NetworkMessageDelegate <11>__HandleReplyClient;
		}

		public const string PluginGUID = "com.bepis.r2api.networking";

		public const string PluginName = "R2API.Networking";

		private static readonly Dictionary<int, INetMessage> NetMessages = new Dictionary<int, INetMessage>();

		private static readonly Dictionary<int, INetCommand> NetCommands = new Dictionary<int, INetCommand>();

		private static readonly Dictionary<int, RequestPerformerBase> NetRequests = new Dictionary<int, RequestPerformerBase>();

		private static bool _hooksEnabled = false;

		public const string PluginVersion = "1.0.4";

		[Obsolete("All submodules are automatically loaded and this property is now unused")]
		public static bool Loaded => true;

		internal static short MessageIndex => 2048;

		internal static short CommandIndex => 4096;

		internal static short RequestIndex => 6144;

		internal static short ReplyIndex => 8192;

		private static NetworkWriter UniversalWriter { get; } = new NetworkWriter();


		public static bool RegisterMessageType<TMessage>() where TMessage : INetMessage, new()
		{
			SetHooks();
			return RegisterMessageTypeInternal<TMessage>();
		}

		internal static bool RegisterMessageTypeInternal<TMessage>() where TMessage : INetMessage, new()
		{
			TMessage val = new TMessage();
			int networkHash = GetNetworkHash(val.GetType());
			if (NetMessages.ContainsKey(networkHash))
			{
				NetworkingPlugin.Logger.LogError((object)"Tried to register a message type with a duplicate hash");
				return false;
			}
			NetMessages[networkHash] = val;
			return true;
		}

		public static bool RegisterCommandType<TCommand>() where TCommand : INetCommand, new()
		{
			SetHooks();
			return RegisterCommandTypeInternal<TCommand>();
		}

		internal static bool RegisterCommandTypeInternal<TCommand>() where TCommand : INetCommand, new()
		{
			TCommand val = new TCommand();
			int networkHash = GetNetworkHash(val.GetType());
			if (NetCommands.ContainsKey(networkHash))
			{
				NetworkingPlugin.Logger.LogError((object)"Tried to register a command type with a duplicate hash");
				return false;
			}
			NetCommands[networkHash] = val;
			return true;
		}

		public static bool RegisterRequestTypes<TRequest, TReply>() where TRequest : INetRequest<TRequest, TReply>, new() where TReply : INetRequestReply<TRequest, TReply>, new()
		{
			SetHooks();
			return RegisterRequestTypesInternal<TRequest, TReply>();
		}

		internal static bool RegisterRequestTypesInternal<TRequest, TReply>() where TRequest : INetRequest<TRequest, TReply>, new() where TReply : INetRequestReply<TRequest, TReply>, new()
		{
			TRequest request = new TRequest();
			TReply reply = new TReply();
			int networkHash = GetNetworkHash(request.GetType());
			if (NetRequests.ContainsKey(networkHash))
			{
				NetworkingPlugin.Logger.LogError((object)"Tried to register a request type with a duplicate hash");
				return false;
			}
			NetRequests[networkHash] = new RequestPerformer<TRequest, TReply>(request, reply);
			return true;
		}

		internal static void SetHooks()
		{
			if (!_hooksEnabled)
			{
				RegisterMessageTypeInternal<DamageMessage>();
				RegisterMessageTypeInternal<BuffMessage>();
				RegisterMessageTypeInternal<DotMessage>();
				RegisterMessageTypeInternal<ExampleMessage>();
				RegisterRequestTypesInternal<ExamplePing, ExamplePingReply>();
				NetworkManagerSystem.onStartServerGlobal += RegisterServerHandlers;
				NetworkManagerSystem.onStartClientGlobal += RegisterClientHandlers;
				NetworkManagerSystem.onStopServerGlobal -= UnRegisterServerHandlers;
				NetworkManagerSystem.onStopClientGlobal -= UnRegisterClientHandlers;
				_hooksEnabled = true;
			}
		}

		internal static void UnsetHooks()
		{
			NetworkManagerSystem.onStartServerGlobal -= RegisterServerHandlers;
			NetworkManagerSystem.onStartClientGlobal -= RegisterClientHandlers;
			NetworkManagerSystem.onStopServerGlobal += UnRegisterServerHandlers;
			NetworkManagerSystem.onStopClientGlobal += UnRegisterClientHandlers;
			_hooksEnabled = false;
		}

		private static void RegisterServerHandlers()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			//IL_006e: 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: Expected O, but got Unknown
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			NetworkingPlugin.Logger.LogInfo((object)"Server Handlers registered");
			short messageIndex = MessageIndex;
			object obj = <>O.<4>__HandleMessageServer;
			if (obj == null)
			{
				NetworkMessageDelegate val = HandleMessageServer;
				<>O.<4>__HandleMessageServer = val;
				obj = (object)val;
			}
			NetworkServer.RegisterHandler(messageIndex, (NetworkMessageDelegate)obj);
			short commandIndex = CommandIndex;
			object obj2 = <>O.<5>__HandleCommandServer;
			if (obj2 == null)
			{
				NetworkMessageDelegate val2 = HandleCommandServer;
				<>O.<5>__HandleCommandServer = val2;
				obj2 = (object)val2;
			}
			NetworkServer.RegisterHandler(commandIndex, (NetworkMessageDelegate)obj2);
			short requestIndex = RequestIndex;
			object obj3 = <>O.<6>__HandleRequestServer;
			if (obj3 == null)
			{
				NetworkMessageDelegate val3 = HandleRequestServer;
				<>O.<6>__HandleRequestServer = val3;
				obj3 = (object)val3;
			}
			NetworkServer.RegisterHandler(requestIndex, (NetworkMessageDelegate)obj3);
			short replyIndex = ReplyIndex;
			object obj4 = <>O.<7>__HandleReplyServer;
			if (obj4 == null)
			{
				NetworkMessageDelegate val4 = HandleReplyServer;
				<>O.<7>__HandleReplyServer = val4;
				obj4 = (object)val4;
			}
			NetworkServer.RegisterHandler(replyIndex, (NetworkMessageDelegate)obj4);
		}

		private static void RegisterClientHandlers(NetworkClient client)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			NetworkingPlugin.Logger.LogInfo((object)"Client Handlers registered");
			short messageIndex = MessageIndex;
			object obj = <>O.<8>__HandleMessageClient;
			if (obj == null)
			{
				NetworkMessageDelegate val = HandleMessageClient;
				<>O.<8>__HandleMessageClient = val;
				obj = (object)val;
			}
			client.RegisterHandler(messageIndex, (NetworkMessageDelegate)obj);
			short commandIndex = CommandIndex;
			object obj2 = <>O.<9>__HandleCommandClient;
			if (obj2 == null)
			{
				NetworkMessageDelegate val2 = HandleCommandClient;
				<>O.<9>__HandleCommandClient = val2;
				obj2 = (object)val2;
			}
			client.RegisterHandler(commandIndex, (NetworkMessageDelegate)obj2);
			short requestIndex = RequestIndex;
			object obj3 = <>O.<10>__HandleRequestClient;
			if (obj3 == null)
			{
				NetworkMessageDelegate val3 = HandleRequestClient;
				<>O.<10>__HandleRequestClient = val3;
				obj3 = (object)val3;
			}
			client.RegisterHandler(requestIndex, (NetworkMessageDelegate)obj3);
			short replyIndex = ReplyIndex;
			object obj4 = <>O.<11>__HandleReplyClient;
			if (obj4 == null)
			{
				NetworkMessageDelegate val4 = HandleReplyClient;
				<>O.<11>__HandleReplyClient = val4;
				obj4 = (object)val4;
			}
			client.RegisterHandler(replyIndex, (NetworkMessageDelegate)obj4);
		}

		private static void UnRegisterServerHandlers()
		{
			NetworkingPlugin.Logger.LogInfo((object)"Server Handlers unregistered");
			NetworkServer.UnregisterHandler(MessageIndex);
			NetworkServer.UnregisterHandler(CommandIndex);
			NetworkServer.UnregisterHandler(RequestIndex);
			NetworkServer.UnregisterHandler(ReplyIndex);
		}

		private static void UnRegisterClientHandlers()
		{
			NetworkingPlugin.Logger.LogInfo((object)"Client Handlers unregistered");
			foreach (NetworkClient allClient in NetworkClient.allClients)
			{
				allClient.UnregisterHandler(MessageIndex);
				allClient.UnregisterHandler(CommandIndex);
				allClient.UnregisterHandler(RequestIndex);
				allClient.UnregisterHandler(ReplyIndex);
			}
		}

		internal static int GetNetworkHash(Type type)
		{
			return (type.Assembly.FullName + type.FullName).GetHashCode();
		}

		internal static Writer GetWriter(short messageIndex, NetworkConnection target, QosType qos)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			return new Writer(UniversalWriter, messageIndex, target, qos);
		}

		private static void HandleCommandServer(NetworkMessage msg)
		{
			Header header = msg.reader.Read<Header>();
			if (header.Destination.ShouldRun())
			{
				header.RemoveDestination(NetworkDestination.Server);
				if (NetCommands.TryGetValue(header.TypeCode, out INetCommand value))
				{
					value.OnReceived();
				}
				else
				{
					NetworkingPlugin.Logger.LogError((object)"Unhandled command received, you may be missing mods");
				}
			}
			if (!header.Destination.ShouldSend())
			{
				return;
			}
			int connectionId = msg.conn.connectionId;
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				if (i == connectionId)
				{
					continue;
				}
				NetworkConnection val = NetworkServer.connections[i];
				if (val != null && (!NetworkServer.localClientActive || !NetworkServer.localConnections.Contains(val)))
				{
					using Writer writer = GetWriter(CommandIndex, val, (QosType)3);
					SerializableObjectExtensions.Write(writer, header);
				}
			}
		}

		private static void HandleMessageServer(NetworkMessage msg)
		{
			NetworkReader reader = msg.reader;
			Header header = reader.Read<Header>();
			if (header.Destination.ShouldRun())
			{
				header.RemoveDestination(NetworkDestination.Server);
				if (NetMessages.TryGetValue(header.TypeCode, out INetMessage value))
				{
					value.Deserialize(reader);
					value.OnReceived();
				}
				else
				{
					NetworkingPlugin.Logger.LogError((object)"Unhandled message received, you may be missing mods");
				}
			}
			if (!header.Destination.ShouldSend())
			{
				return;
			}
			int connectionId = msg.conn.connectionId;
			byte[] array = reader.ReadBytes((int)(reader.Length - reader.Position));
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				if (i == connectionId)
				{
					continue;
				}
				NetworkConnection val = NetworkServer.connections[i];
				if (val != null && (!NetworkServer.localClientActive || !NetworkServer.localConnections.Contains(val)))
				{
					using Writer writer = GetWriter(MessageIndex, val, (QosType)3);
					NetworkWriter obj = writer;
					obj.Write(header);
					obj.WriteBytesFull(array);
				}
			}
		}

		private static void HandleRequestServer(NetworkMessage msg)
		{
			NetworkReader reader = msg.reader;
			Header header = reader.Read<Header>();
			if (header.Destination.ShouldRun())
			{
				header.RemoveDestination(NetworkDestination.Server);
				if (NetRequests.TryGetValue(header.TypeCode, out RequestPerformerBase value))
				{
					ISerializableObject target = value.PerformRequest(reader);
					Header target2 = new Header(header.TypeCode, NetworkDestination.Clients);
					using Writer writer = GetWriter(ReplyIndex, msg.conn, (QosType)3);
					NetworkWriter writer2 = writer;
					writer2.Write(target2);
					writer2.Write(target);
				}
				else
				{
					NetworkingPlugin.Logger.LogError((object)"Unhandled request message received, you may be missing mods");
				}
			}
			if (!header.Destination.ShouldSend())
			{
				return;
			}
			int connectionId = msg.conn.connectionId;
			byte[] array = reader.ReadBytes((int)(reader.Length - reader.Position));
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				if (i == connectionId)
				{
					continue;
				}
				NetworkConnection val = NetworkServer.connections[i];
				if (val != null && (!NetworkServer.localClientActive || !NetworkServer.localConnections.Contains(val)))
				{
					using Writer writer3 = GetWriter(RequestIndex, val, (QosType)3);
					NetworkWriter obj = writer3;
					obj.Write(header);
					obj.WriteBytesFull(array);
				}
			}
		}

		private static void HandleReplyServer(NetworkMessage msg)
		{
			NetworkReader reader = msg.reader;
			Header header = reader.Read<Header>();
			if (header.Destination.ShouldRun())
			{
				header.RemoveDestination(NetworkDestination.Server);
				if (NetRequests.TryGetValue(header.TypeCode, out RequestPerformerBase value))
				{
					value.PerformReply(reader);
				}
				else
				{
					NetworkingPlugin.Logger.LogError((object)"Unhandled reply received, you may be missing mods");
				}
			}
			if (!header.Destination.ShouldSend())
			{
				return;
			}
			int connectionId = msg.conn.connectionId;
			for (int i = 0; i < NetworkServer.connections.Count; i++)
			{
				if (i == connectionId)
				{
					continue;
				}
				NetworkConnection val = NetworkServer.connections[i];
				if (val != null && (!NetworkServer.localClientActive || !NetworkServer.localConnections.Contains(val)))
				{
					using Writer writer = GetWriter(RequestIndex, val, (QosType)3);
					SerializableObjectExtensions.Write(writer, header);
				}
			}
		}

		private static void HandleCommandClient(NetworkMessage msg)
		{
			Header header = msg.reader.Read<Header>();
			if (header.Destination.ShouldRun())
			{
				header.RemoveDestination(NetworkDestination.Clients);
				if (NetCommands.TryGetValue(header.TypeCode, out INetCommand value))
				{
					value.OnReceived();
				}
				else
				{
					NetworkingPlugin.Logger.LogError((object)"Unhandled command received, you may be missing mods");
				}
			}
		}

		private static void HandleMessageClient(NetworkMessage msg)
		{
			NetworkReader reader = msg.reader;
			Header header = reader.Read<Header>();
			if (header.Destination.ShouldRun())
			{
				header.RemoveDestination(NetworkDestination.Clients);
				if (NetMessages.TryGetValue(header.TypeCode, out INetMessage value))
				{
					value.Deserialize(reader);
					value.OnReceived();
				}
				else
				{
					NetworkingPlugin.Logger.LogError((object)"Unhandled message received, you may be missing mods");
				}
			}
		}

		private static void HandleRequestClient(NetworkMessage msg)
		{
			NetworkReader reader = msg.reader;
			Header header = reader.Read<Header>();
			if (!header.Destination.ShouldRun())
			{
				return;
			}
			header.RemoveDestination(NetworkDestination.Clients);
			if (NetRequests.TryGetValue(header.TypeCode, out RequestPerformerBase value))
			{
				ISerializableObject target = value.PerformRequest(reader);
				Header target2 = new Header(header.TypeCode, NetworkDestination.Clients);
				using Writer writer = GetWriter(ReplyIndex, msg.conn, (QosType)3);
				NetworkWriter writer2 = writer;
				writer2.Write(target2);
				writer2.Write(target);
				return;
			}
			NetworkingPlugin.Logger.LogError((object)"Unhandled request message received, you may be missing mods");
		}

		private static void HandleReplyClient(NetworkMessage msg)
		{
			NetworkReader reader = msg.reader;
			Header header = reader.Read<Header>();
			if (header.Destination.ShouldRun())
			{
				header.RemoveDestination(NetworkDestination.Clients);
				if (NetRequests.TryGetValue(header.TypeCode, out RequestPerformerBase value))
				{
					value.PerformReply(reader);
				}
				else
				{
					NetworkingPlugin.Logger.LogError((object)"Unhandled reply received, you may be missing mods");
				}
			}
		}
	}
	public static class NetworkingHelpers
	{
		public static void DealDamage(this DamageInfo? damage, HurtBox? target, bool callDamage, bool callHitEnemy, bool callHitWorld)
		{
			if (NetworkServer.active)
			{
				if (callDamage && (Object)(object)target != (Object)null && (Object)(object)target.healthComponent != (Object)null)
				{
					target.healthComponent.TakeDamage(damage);
				}
				if (callHitEnemy && (Object)(object)target != (Object)null && (Object)(object)target.healthComponent != (Object)null)
				{
					GlobalEventManager.instance.OnHitEnemy(damage, ((Component)target.healthComponent).gameObject);
				}
				if (callHitWorld)
				{
					GlobalEventManager.instance.OnHitAll(damage, (Object.op_Implicit((Object)(object)target) && Object.op_Implicit((Object)(object)target.healthComponent)) ? ((Component)target.healthComponent).gameObject : null);
				}
			}
			else
			{
				new DamageMessage(damage, target, callDamage, callHitEnemy, callHitWorld).Send(NetworkDestination.Server);
			}
		}

		public static void ApplyBuff(this CharacterBody? body, BuffIndex buff, int stacks = 1, float duration = -1f)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkServer.active)
			{
				if (duration < 0f)
				{
					body.SetBuffCount(buff, stacks);
					return;
				}
				if (stacks < 0)
				{
					NetworkingPlugin.Logger.LogError((object)"Cannot remove duration from a buff");
					return;
				}
				for (int i = 0; i < stacks; i++)
				{
					body.AddTimedBuff(buff, duration);
				}
			}
			else
			{
				new BuffMessage(body, buff, stacks, duration).Send(NetworkDestination.Server);
			}
		}

		public static void ApplyDot(this HealthComponent victim, GameObject attacker, DotIndex dotIndex, float duration = 8f, float damageMultiplier = 1f)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			victim.ApplyDot(new InflictDotInfo
			{
				victimObject = ((Component)victim).gameObject,
				attackerObject = attacker,
				dotIndex = dotIndex,
				duration = duration,
				damageMultiplier = damageMultiplier
			});
		}

		public static void ApplyDot(this HealthComponent victim, InflictDotInfo inflictDotInfo)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (NetworkServer.active)
			{
				DotController.InflictDot(ref inflictDotInfo);
			}
			else
			{
				new DotMessage(inflictDotInfo).Send(NetworkDestination.Server);
			}
		}
	}
	[BepInPlugin("com.bepis.r2api.networking", "R2API.Networking", "1.0.4")]
	public sealed class NetworkingPlugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger { get; set; }

		private void Awake()
		{
			Logger = ((BaseUnityPlugin)this).Logger;
			NetworkingAPI.SetHooks();
		}

		private void OnDestroy()
		{
			NetworkingAPI.UnsetHooks();
		}
	}
	internal abstract class RequestPerformerBase
	{
		internal abstract ISerializableObject PerformRequest(NetworkReader reader);

		internal abstract void PerformReply(NetworkReader reader);
	}
	internal sealed class RequestPerformer<TRequest, TReply> : RequestPerformerBase where TRequest : INetRequest<TRequest, TReply> where TReply : INetRequestReply<TRequest, TReply>
	{
		private readonly TRequest _request;

		private readonly TReply _reply;

		internal RequestPerformer(TRequest request, TReply reply)
		{
			_request = request;
			_reply = reply;
		}

		internal override ISerializableObject PerformRequest(NetworkReader reader)
		{
			_request.Deserialize(reader);
			return _request.OnRequestReceived();
		}

		internal override void PerformReply(NetworkReader reader)
		{
			_reply.Deserialize(reader);
			_reply.OnReplyReceived();
		}
	}
	internal class Writer : IDisposable
	{
		private readonly NetworkWriter _netWriter;

		private readonly NetworkConnection _target;

		private readonly QosType _qos;

		internal Writer(NetworkWriter writer, short messageIndex, NetworkConnection target, QosType qos)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			_netWriter = writer;
			_target = target;
			_qos = qos;
			writer.StartMessage(messageIndex);
		}

		public static implicit operator NetworkWriter(Writer writer)
		{
			return writer._netWriter;
		}

		public void Dispose()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected I4, but got Unknown
			_netWriter.FinishMessage();
			_target.SendWriter(_netWriter, (int)_qos);
		}
	}
}
namespace R2API.Networking.Messages
{
	internal struct BuffMessage : INetMessage, ISerializableObject
	{
		private CharacterBody _body;

		private BuffIndex _buff;

		private int _stacks;

		private float _duration;

		public void Serialize(NetworkWriter writer)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			writer.Write(((Component)_body).gameObject);
			NetworkExtensions.WriteBuffIndex(writer, _buff);
			writer.Write(_stacks);
			writer.Write(_duration);
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			_body = reader.ReadGameObject().GetComponent<CharacterBody>();
			_buff = NetworkExtensions.ReadBuffIndex(reader);
			_stacks = reader.ReadInt32();
			_duration = reader.ReadSingle();
		}

		public void OnReceived()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			_body.ApplyBuff(_buff, _stacks, _duration);
		}

		internal BuffMessage(CharacterBody body, BuffIndex buff, int stacks, float duration)
		{
			//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)
			_body = body;
			_buff = buff;
			_stacks = stacks;
			_duration = duration;
		}
	}
	internal struct DamageMessage : INetMessage, ISerializableObject
	{
		private DamageInfo _damage;

		private HurtBox _target;

		private bool _callDamage;

		private bool _callHitEnemy;

		private bool _callHitWorld;

		public void Serialize(NetworkWriter writer)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			NetworkExtensions.Write(writer, _damage);
			NetworkExtensions.Write(writer, HurtBoxReference.FromHurtBox(_target));
			byte b = 0;
			b = (byte)((uint)b | (_callHitWorld ? 1u : 0u));
			b <<= 1;
			b = (byte)((uint)b | (_callHitEnemy ? 1u : 0u));
			b <<= 1;
			b = (byte)((uint)b | (_callDamage ? 1u : 0u));
			writer.Write(b);
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			_damage = NetworkExtensions.ReadDamageInfo(reader);
			HurtBoxReference val = NetworkExtensions.ReadHurtBoxReference(reader);
			_target = ((HurtBoxReference)(ref val)).ResolveHurtBox();
			byte b = reader.ReadByte();
			_callDamage = (b & 1) > 0;
			b >>= 1;
			_callHitEnemy = (b & 1) > 0;
			b >>= 1;
			_callHitWorld = (b & 1) > 0;
		}

		public void OnReceived()
		{
			_damage.DealDamage(_target, _callDamage, _callHitEnemy, _callHitWorld);
		}

		internal DamageMessage(DamageInfo damage, HurtBox target, bool callDamage, bool callHitEnemy, bool callHitWorld)
		{
			_damage = damage;
			_target = target;
			_callDamage = callDamage;
			_callHitEnemy = callHitEnemy;
			_callHitWorld = callHitWorld;
		}
	}
	internal struct DotMessage : INetMessage, ISerializableObject
	{
		private static readonly bool[] _nullableFieldsSharedHasValueArray = new bool[3];

		private GameObject _victim;

		private GameObject _attacker;

		private DotIndex _dotIndex;

		private float _duration;

		private float _damageMultiplier;

		private uint? _maxStacksFromAttacker;

		private float? _totalDamage;

		private DotIndex? _preUpgradeDotIndex;

		private HurtBoxReference _hitHurtBox;

		public void Serialize(NetworkWriter writer)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected I4, but got Unknown
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected I4, but got Unknown
			writer.Write(_victim);
			writer.Write(_attacker);
			NetworkExtensions.WritePackedIndex32(writer, (int)_dotIndex);
			writer.Write(_duration);
			writer.Write(_damageMultiplier);
			int num = 0;
			_nullableFieldsSharedHasValueArray[num++] = _maxStacksFromAttacker.HasValue;
			_nullableFieldsSharedHasValueArray[num++] = _totalDamage.HasValue;
			_nullableFieldsSharedHasValueArray[num++] = _preUpgradeDotIndex.HasValue;
			NetworkExtensions.WriteBitArray(writer, _nullableFieldsSharedHasValueArray);
			if (_maxStacksFromAttacker.HasValue)
			{
				writer.WritePackedUInt32(_maxStacksFromAttacker.Value);
			}
			if (_totalDamage.HasValue)
			{
				writer.Write(_totalDamage.Value);
			}
			if (_preUpgradeDotIndex.HasValue)
			{
				NetworkExtensions.WritePackedIndex32(writer, (int)_preUpgradeDotIndex.Value);
			}
			NetworkExtensions.Write(writer, _hitHurtBox);
		}

		public void Deserialize(NetworkReader reader)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: 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)
			_victim = reader.ReadGameObject();
			_attacker = reader.ReadGameObject();
			_dotIndex = (DotIndex)NetworkExtensions.ReadPackedIndex32(reader);
			_duration = reader.ReadSingle();
			_damageMultiplier = reader.ReadSingle();
			NetworkExtensions.ReadBitArray(reader, _nullableFieldsSharedHasValueArray);
			int num = 0;
			bool num2 = _nullableFieldsSharedHasValueArray[num++];
			bool flag = _nullableFieldsSharedHasValueArray[num++];
			bool flag2 = _nullableFieldsSharedHasValueArray[num++];
			if (num2)
			{
				_maxStacksFromAttacker = reader.ReadPackedUInt32();
			}
			if (flag)
			{
				_totalDamage = reader.ReadSingle();
			}
			if (flag2)
			{
				_preUpgradeDotIndex = (DotIndex)NetworkExtensions.ReadPackedIndex32(reader);
			}
			_hitHurtBox = NetworkExtensions.ReadHurtBoxReference(reader);
		}

		public void OnReceived()
		{
			//IL_0002: 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_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			InflictDotInfo val = default(InflictDotInfo);
			val.victimObject = _victim;
			val.attackerObject = _attacker;
			val.dotIndex = _dotIndex;
			val.duration = _duration;
			val.damageMultiplier = _damageMultiplier;
			val.maxStacksFromAttacker = _maxStacksFromAttacker;
			val.totalDamage = _totalDamage;
			val.preUpgradeDotIndex = _preUpgradeDotIndex;
			val.hitHurtBox = ((HurtBoxReference)(ref _hitHurtBox)).ResolveHurtBox();
			InflictDotInfo val2 = val;
			DotController.InflictDot(ref val2);
		}

		internal DotMessage(InflictDotInfo inflictDotInfo)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: 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_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			_victim = inflictDotInfo.victimObject;
			_attacker = inflictDotInfo.attackerObject;
			_dotIndex = inflictDotInfo.dotIndex;
			_duration = inflictDotInfo.duration;
			_damageMultiplier = inflictDotInfo.damageMultiplier;
			_maxStacksFromAttacker = inflictDotInfo.maxStacksFromAttacker;
			_totalDamage = inflictDotInfo.totalDamage;
			_preUpgradeDotIndex = inflictDotInfo.preUpgradeDotIndex;
			_hitHurtBox = HurtBoxReference.FromHurtBox(inflictDotInfo.hitHurtBox);
		}
	}
	internal struct ExampleMessage : INetMessage, ISerializableObject
	{
		internal int Integer;

		internal string Str;

		public void Serialize(NetworkWriter writer)
		{
			writer.Write(Integer);
			writer.Write(Str);
		}

		public void Deserialize(NetworkReader reader)
		{
			Integer = reader.ReadInt32();
			Str = reader.ReadString();
		}

		public void OnReceived()
		{
			NetworkingPlugin.Logger.LogWarning((object)("int : " + Integer + " str : " + Str));
		}
	}
	internal struct ExamplePing : INetRequest<ExamplePing, ExamplePingReply>, ISerializableObject
	{
		internal int Integer;

		public void Serialize(NetworkWriter writer)
		{
			writer.Write(Integer);
		}

		public void Deserialize(NetworkReader reader)
		{
			Integer = reader.ReadInt32();
		}

		public ExamplePingReply OnRequestReceived()
		{
			NetworkingPlugin.Logger.LogWarning((object)("ExamplePing - Received this request : " + Integer));
			ExamplePingReply result = default(ExamplePingReply);
			result.Str = "I'm answering you back this string";
			return result;
		}
	}
	internal struct ExamplePingReply : INetRequestReply<ExamplePing, ExamplePingReply>, ISerializableObject
	{
		internal string Str;

		public void Serialize(NetworkWriter writer)
		{
			writer.Write(Str);
		}

		public void Deserialize(NetworkReader reader)
		{
			Str = reader.ReadString();
		}

		public void OnReplyReceived()
		{
			NetworkingPlugin.Logger.LogWarning((object)("ExamplePingReply - Received this Reply : " + Str));
		}
	}
}
namespace R2API.Networking.Interfaces
{
	public interface INetCommand
	{
		void OnReceived();
	}
	public static class NetCommandExtensions
	{
		private static void SendCommand(Header header, NetworkConnection conn)
		{
			using Writer writer = NetworkingAPI.GetWriter(NetworkingAPI.CommandIndex, conn, (QosType)3);
			SerializableObjectExtensions.Write(writer, header);
		}

		public static void Send(this INetCommand? command, NetworkDestination destination)
		{
			if (destination.ShouldRun())
			{
				command.OnReceived();
			}
			if (!destination.ShouldSend())
			{
				return;
			}
			Header header = destination.GetHeader(NetworkingAPI.GetNetworkHash(command.GetType()));
			if (NetworkServer.active)
			{
				for (int i = 0; i < NetworkServer.connections.Count; i++)
				{
					NetworkConnection val = NetworkServer.connections[i];
					if (val != null && (!NetworkServer.localClientActive || !NetworkServer.localConnections.Contains(val)))
					{
						SendCommand(header, val);
					}
				}
			}
			else if (NetworkClient.active)
			{
				SendCommand(header, ClientScene.readyConnection);
			}
		}

		public static void Send(this INetCommand? command, NetworkConnection target)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (!NetworkServer.active)
			{
				throw new InvalidOperationException("NetworkServer is not active.");
			}
			if (NetworkClient.active)
			{
				foreach (NetworkClient allClient in NetworkClient.allClients)
				{
					if (allClient.connection != null && allClient.connection.connectionId == target.connectionId)
					{
						command.OnReceived();
						return;
					}
				}
			}
			SendCommand(NetworkDestination.Clients.GetHeader(NetworkingAPI.GetNetworkHash(command.GetType())), target);
		}
	}
	public interface INetMessage : ISerializableObject
	{
		void OnReceived();
	}
	public static class NetMessageExtensions
	{
		private static void SendMessage(INetMessage? message, Header header, NetworkConnection conn)
		{
			using Writer writer = NetworkingAPI.GetWriter(NetworkingAPI.MessageIndex, conn, (QosType)3);
			NetworkWriter writer2 = writer;
			writer2.Write(header);
			writer2.Write(message);
		}

		public static void Send(this INetMessage? message, NetworkDestination destination)
		{
			if (destination.ShouldRun())
			{
				message.OnReceived();
			}
			if (!destination.ShouldSend())
			{
				return;
			}
			Header header = destination.GetHeader(NetworkingAPI.GetNetworkHash(message.GetType()));
			if (NetworkServer.active)
			{
				for (int i = 0; i < NetworkServer.connections.Count; i++)
				{
					NetworkConnection val = NetworkServer.connections[i];
					if (val != null && (!NetworkServer.localClientActive || !NetworkServer.localConnections.Contains(val)))
					{
						SendMessage(message, header, val);
					}
				}
			}
			else if (NetworkClient.active)
			{
				SendMessage(message, header, ClientScene.readyConnection);
			}
		}

		public static void Send(this INetMessage? message, NetworkConnection target)
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (!NetworkServer.active)
			{
				throw new InvalidOperationException("NetworkServer is not active.");
			}
			if (NetworkClient.active)
			{
				foreach (NetworkClient allClient in NetworkClient.allClients)
				{
					if (allClient.connection != null && allClient.connection.connectionId == target.connectionId)
					{
						message.OnReceived();
						return;
					}
				}
			}
			Header header = NetworkDestination.Clients.GetHeader(NetworkingAPI.GetNetworkHash(message.GetType()));
			SendMessage(message, header, target);
		}
	}
	public interface INetRequest<TRequest, TReply> : ISerializableObject where TRequest : INetRequest<TRequest, TReply> where TReply : INetRequestReply<TRequest, TReply>
	{
		TReply OnRequestReceived();
	}
	public interface INetRequestReply<TRequest, TReply> : ISerializableObject where TRequest : INetRequest<TRequest, TReply> where TReply : INetRequestReply<TRequest, TReply>
	{
		void OnReplyReceived();
	}
	public static class NetRequestExtensions
	{
		private static void SendRequest<TRequest, TReply>(TRequest request, Header header, NetworkConnection conn) where TRequest : INetRequest<TRequest, TReply> where TReply : INetRequestReply<TRequest, TReply>
		{
			using Writer writer = NetworkingAPI.GetWriter(NetworkingAPI.RequestIndex, conn, (QosType)3);
			NetworkWriter writer2 = writer;
			writer2.Write(header);
			writer2.Write(request);
		}

		public static void Send<TRequest, TReply>(this TRequest request, NetworkDestination destination) where TRequest : INetRequest<TRequest, TReply> where TReply : INetRequestReply<TRequest, TReply>
		{
			if (destination.ShouldRun())
			{
				request.OnRequestReceived().OnReplyReceived();
			}
			if (!destination.ShouldSend())
			{
				return;
			}
			Header header = destination.GetHeader(NetworkingAPI.GetNetworkHash(request.GetType()));
			if (NetworkServer.active)
			{
				for (int i = 0; i < NetworkServer.connections.Count; i++)
				{
					NetworkConnection val = NetworkServer.connections[i];
					if (val != null && (!NetworkServer.localClientActive || !NetworkServer.localConnections.Contains(val)))
					{
						SendRequest<TRequest, TReply>(request, header, val);
					}
				}
			}
			else if (NetworkClient.active)
			{
				SendRequest<TRequest, TReply>(request, header, ClientScene.readyConnection);
			}
		}

		public static void Send<TRequest, TReply>(this TRequest request, NetworkConnection target) where TRequest : INetRequest<TRequest, TReply> where TReply : INetRequestReply<TRequest, TReply>
		{
			if (target == null)
			{
				throw new ArgumentNullException("target");
			}
			if (!NetworkServer.active)
			{
				throw new InvalidOperationException("NetworkServer is not active.");
			}
			if (NetworkClient.active)
			{
				foreach (NetworkClient allClient in NetworkClient.allClients)
				{
					if (allClient.connection != null && allClient.connection.connectionId == target.connectionId)
					{
						request.OnRequestReceived().OnReplyReceived();
						return;
					}
				}
			}
			Header header = NetworkDestination.Clients.GetHeader(NetworkingAPI.GetNetworkHash(request.GetType()));
			SendRequest<TRequest, TReply>(request, header, target);
		}
	}
	public interface ISerializableObject
	{
		void Serialize(NetworkWriter writer);

		void Deserialize(NetworkReader reader);
	}
	public static class SerializableObjectExtensions
	{
		public static void Write<TObject>(this NetworkWriter? writer, TObject target) where TObject : ISerializableObject
		{
			target.Serialize(writer);
		}

		public static TObject Read<TObject>(this NetworkReader? reader, TObject destination) where TObject : ISerializableObject
		{
			destination.Deserialize(reader);
			return destination;
		}

		public static TObject Read<TObject>(this NetworkReader? reader) where TObject : ISerializableObject, new()
		{
			TObject result = new TObject();
			result.Deserialize(reader);
			return result;
		}
	}
	public interface ISerializer<TObject>
	{
		void Serialize(NetworkWriter writer, TObject target);

		void Deserialize(NetworkReader reader, TObject target);
	}
	public static class SerializerExtensions
	{
		public static void Write<TObject>(this NetworkWriter? writer, TObject target, ISerializer<TObject>? serializer)
		{
			serializer.Serialize(writer, target);
		}

		public static TObject Read<TObject>(this NetworkReader? reader, ref TObject destination, ISerializer<TObject>? serializer)
		{
			serializer.Deserialize(reader, destination);
			return destination;
		}
	}
}