Restructuring of the files

Facepunch.Steamworks/SteamNetworking.cs

@@ -0,0 +1,144 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using Facepunch.Steamworks.Data;
+
+namespace Facepunch.Steamworks
+{
+	public class SteamNetworking : SteamSharedClass<SteamNetworking>
+	{
+		internal static ISteamNetworking Internal => Interface as ISteamNetworking;
+
+		internal override void InitializeInterface( bool server )
+		{
+			SetInterface( server, new ISteamNetworking( server ) );
+
+			InstallEvents( server );
+		}
+
+		internal static void InstallEvents( bool server )
+		{
+			Dispatch.Install<P2PSessionRequest_t>( x => OnP2PSessionRequest?.Invoke( x.SteamIDRemote ), server );
+			Dispatch.Install<P2PSessionConnectFail_t>( x => OnP2PConnectionFailed?.Invoke( x.SteamIDRemote, (P2PSessionError) x.P2PSessionError ), server );
+		}
+
+		/// <summary>
+		/// This SteamId wants to send you a message. You should respond by calling AcceptP2PSessionWithUser
+		/// if you want to recieve their messages
+		/// </summary>
+		public static Action<SteamId> OnP2PSessionRequest;
+
+		/// <summary>
+		/// Called when packets can't get through to the specified user.
+		/// All queued packets unsent at this point will be dropped, further attempts
+		/// to send will retry making the connection (but will be dropped if we fail again).
+		/// </summary>
+		public static Action<SteamId, P2PSessionError> OnP2PConnectionFailed;
+
+		/// <summary>
+		/// This should be called in response to a OnP2PSessionRequest
+		/// </summary>
+		public static bool AcceptP2PSessionWithUser( SteamId user ) => Internal.AcceptP2PSessionWithUser( user );
+
+		/// <summary>
+		/// Allow or disallow P2P connects to fall back on Steam server relay if direct 
+		/// connection or NAT traversal can't be established. Applies to connections 
+		/// created after setting or old connections that need to reconnect.
+		/// </summary>
+		public static bool AllowP2PPacketRelay( bool allow ) => Internal.AllowP2PPacketRelay( allow );
+
+		/// <summary>
+		/// This should be called when you're done communicating with a user, as this will
+		/// free up all of the resources allocated for the connection under-the-hood.
+		/// If the remote user tries to send data to you again, a new OnP2PSessionRequest 
+		/// callback will be posted
+		/// </summary>
+		public static bool CloseP2PSessionWithUser( SteamId user ) => Internal.CloseP2PSessionWithUser( user );
+
+		/// <summary>
+		/// Checks if a P2P packet is available to read, and gets the size of the message if there is one.
+		/// </summary>
+		public static bool IsP2PPacketAvailable( int channel = 0 )
+		{
+			uint _ = 0;
+			return Internal.IsP2PPacketAvailable( ref _, channel );
+		}
+
+		/// <summary>
+		/// Reads in a packet that has been sent from another user via SendP2PPacket..
+		/// </summary>
+		public unsafe static P2Packet? ReadP2PPacket( int channel = 0 )
+		{
+			uint size = 0;
+
+			if ( !Internal.IsP2PPacketAvailable( ref size, channel ) )
+				return null;
+
+			var buffer = Helpers.TakeBuffer( (int) size );
+
+			fixed ( byte* p = buffer )
+			{
+				SteamId steamid = 1;
+				if ( !Internal.ReadP2PPacket( (IntPtr)p, (uint) buffer.Length, ref size, ref steamid, channel ) || size == 0 )
+				    return null;
+
+				var data = new byte[size];
+				Array.Copy( buffer, 0, data, 0, size );
+
+				return new P2Packet
+				{
+					SteamId = steamid,
+					Data = data
+				};
+			}
+		}
+
+		/// <summary>
+		/// Reads in a packet that has been sent from another user via SendP2PPacket..
+		/// </summary>
+		public unsafe static bool ReadP2PPacket( byte[] buffer, ref uint size, ref SteamId steamid, int channel = 0 )
+		{
+			fixed (byte* p = buffer) {
+				return Internal.ReadP2PPacket( (IntPtr)p, (uint)buffer.Length, ref size, ref steamid, channel );
+			}
+		}
+
+		/// <summary>
+		/// Reads in a packet that has been sent from another user via SendP2PPacket..
+		/// </summary>
+		public unsafe static bool ReadP2PPacket( byte* buffer, uint cbuf, ref uint size, ref SteamId steamid, int channel = 0 )
+		{
+			return Internal.ReadP2PPacket( (IntPtr)buffer, cbuf, ref size, ref steamid, channel );
+		}
+
+		/// <summary>
+		/// Sends a P2P packet to the specified user.
+		/// This is a session-less API which automatically establishes NAT-traversing or Steam relay server connections.
+		/// NOTE: The first packet send may be delayed as the NAT-traversal code runs.
+		/// </summary>
+		public static unsafe bool SendP2PPacket( SteamId steamid, byte[] data, int length = -1, int nChannel = 0, P2PSend sendType = P2PSend.Reliable )
+		{
+			if ( length <= 0 )
+				length = data.Length;
+
+			fixed ( byte* p = data )
+			{
+				return Internal.SendP2PPacket( steamid, (IntPtr)p, (uint)length, (P2PSend)sendType, nChannel );
+			}
+		}
+
+		/// <summary>
+		/// Sends a P2P packet to the specified user.
+		/// This is a session-less API which automatically establishes NAT-traversing or Steam relay server connections.
+		/// NOTE: The first packet send may be delayed as the NAT-traversal code runs.
+		/// </summary>
+		public static unsafe bool SendP2PPacket( SteamId steamid, byte* data, uint length, int nChannel = 1, P2PSend sendType = P2PSend.Reliable )
+		{ 
+			return Internal.SendP2PPacket( steamid, (IntPtr)data, (uint)length, (P2PSend)sendType, nChannel );
+		}
+
+	}
+}