Initial Commit

Library/PackageCache/com.unity.multiplayer.mlapi@3e3aef6aa0/Runtime/Transports/NetworkTransport.cs

@@ -0,0 +1,182 @@
+using System;
+using System.Collections.Generic;
+using MLAPI.Transports.Tasks;
+using UnityEngine;
+
+namespace MLAPI.Transports
+{
+    public enum NetworkChannel : byte
+    {
+        Internal,
+        TimeSync,
+        ReliableRpc,
+        UnreliableRpc,
+        SyncChannel,
+        DefaultMessage,
+        PositionUpdate,
+        AnimationUpdate,
+        NavAgentState,
+        NavAgentCorrection,
+        ChannelUnused, // <<-- must be present, and must be last
+    };
+
+    /// <summary>
+    /// A network transport
+    /// </summary>
+    public abstract class NetworkTransport : MonoBehaviour
+    {
+        /// <summary>
+        /// Delegate used to request channels on the underlying transport.
+        /// </summary>
+        public delegate void RequestChannelsDelegate(List<TransportChannel> channels);
+
+        /// <summary>
+        /// Delegate called when the transport wants to know what channels to register.
+        /// </summary>
+        public event RequestChannelsDelegate OnChannelRegistration;
+
+        /// <summary>
+        /// A constant clientId that represents the server.
+        /// When this value is found in methods such as Send, it should be treated as a placeholder that means "the server"
+        /// </summary>
+        public abstract ulong ServerClientId { get; }
+
+        /// <summary>
+        /// Gets a value indicating whether this <see cref="T:MLAPI.Transports.Transport"/> is supported in the current runtime context.
+        /// This is used by multiplex adapters.
+        /// </summary>
+        /// <value><c>true</c> if is supported; otherwise, <c>false</c>.</value>
+        public virtual bool IsSupported => true;
+
+        private TransportChannel[] m_ChannelsCache = null;
+
+        internal void ResetChannelCache()
+        {
+            m_ChannelsCache = null;
+        }
+
+        public TransportChannel[] MLAPI_CHANNELS
+        {
+            get
+            {
+                if (m_ChannelsCache == null)
+                {
+                    var transportChannels = new List<TransportChannel>();
+
+                    OnChannelRegistration?.Invoke(transportChannels);
+
+                    m_ChannelsCache = new TransportChannel[MLAPI_INTERNAL_CHANNELS.Length + transportChannels.Count];
+
+                    for (int i = 0; i < MLAPI_INTERNAL_CHANNELS.Length; i++)
+                    {
+                        m_ChannelsCache[i] = MLAPI_INTERNAL_CHANNELS[i];
+                    }
+
+                    for (int i = 0; i < transportChannels.Count; i++)
+                    {
+                        m_ChannelsCache[i + MLAPI_INTERNAL_CHANNELS.Length] = transportChannels[i];
+                    }
+                }
+
+                return m_ChannelsCache;
+            }
+        }
+
+        /// <summary>
+        /// The channels the MLAPI will use when sending internal messages.
+        /// </summary>
+        private readonly TransportChannel[] MLAPI_INTERNAL_CHANNELS =
+        {
+            new TransportChannel(NetworkChannel.Internal, NetworkDelivery.ReliableFragmentedSequenced),
+            new TransportChannel(NetworkChannel.ReliableRpc, NetworkDelivery.ReliableSequenced),
+            new TransportChannel(NetworkChannel.UnreliableRpc, NetworkDelivery.UnreliableSequenced),
+            new TransportChannel(NetworkChannel.TimeSync, NetworkDelivery.Unreliable),
+            new TransportChannel(NetworkChannel.SyncChannel, NetworkDelivery.Unreliable),
+            new TransportChannel(NetworkChannel.DefaultMessage, NetworkDelivery.Reliable),
+            new TransportChannel(NetworkChannel.PositionUpdate, NetworkDelivery.UnreliableSequenced),
+            new TransportChannel(NetworkChannel.AnimationUpdate, NetworkDelivery.ReliableSequenced),
+            new TransportChannel(NetworkChannel.NavAgentState, NetworkDelivery.ReliableSequenced),
+            new TransportChannel(NetworkChannel.NavAgentCorrection, NetworkDelivery.UnreliableSequenced),
+        };
+
+        /// <summary>
+        /// Delegate for transport events.
+        /// </summary>
+        public delegate void TransportEventDelegate(NetworkEvent type, ulong clientId, NetworkChannel networkChannel, ArraySegment<byte> payload, float receiveTime);
+
+        /// <summary>
+        /// Occurs when the transport has a new transport event. Can be used to make an event based transport instead of a poll based.
+        /// Invokation has to occur on the Unity thread in the Update loop.
+        /// </summary>
+        public event TransportEventDelegate OnTransportEvent;
+
+        /// <summary>
+        /// Invokes the <see cref="OnTransportEvent"/>. Invokation has to occur on the Unity thread in the Update loop.
+        /// </summary>
+        /// <param name="type">The event type</param>
+        /// <param name="clientId">The clientId this event is for</param>
+        /// <param name="channelName">The channel the data arrived at. This is usually used when responding to things like RPCs</param>
+        /// <param name="payload">The incoming data payload</param>
+        /// <param name="receiveTime">The time the event was received, as reported by Time.realtimeSinceStartup.</param>
+        protected void InvokeOnTransportEvent(NetworkEvent type, ulong clientId, NetworkChannel networkChannel, ArraySegment<byte> payload, float receiveTime)
+        {
+            OnTransportEvent?.Invoke(type, clientId, networkChannel, payload, receiveTime);
+        }
+
+        /// <summary>
+        /// Send a payload to the specified clientId, data and channelName.
+        /// </summary>
+        /// <param name="clientId">The clientId to send to</param>
+        /// <param name="data">The data to send</param>
+        /// <param name="channelName">The channel to send data to</param>
+        public abstract void Send(ulong clientId, ArraySegment<byte> data, NetworkChannel networkChannel);
+
+        /// <summary>
+        /// Polls for incoming events, with an extra output parameter to report the precise time the event was received.
+        /// </summary>
+        /// <param name="clientId">The clientId this event is for</param>
+        /// <param name="channelName">The channel the data arrived at. This is usually used when responding to things like RPCs</param>
+        /// <param name="payload">The incoming data payload</param>
+        /// <param name="receiveTime">The time the event was received, as reported by Time.realtimeSinceStartup.</param>
+        /// <returns>Returns the event type</returns>
+        public abstract NetworkEvent PollEvent(out ulong clientId, out NetworkChannel networkChannel, out ArraySegment<byte> payload, out float receiveTime);
+
+        /// <summary>
+        /// Connects client to server
+        /// </summary>
+        public abstract SocketTasks StartClient();
+
+        /// <summary>
+        /// Starts to listen for incoming clients.
+        /// </summary>
+        public abstract SocketTasks StartServer();
+
+        /// <summary>
+        /// Disconnects a client from the server
+        /// </summary>
+        /// <param name="clientId">The clientId to disconnect</param>
+        public abstract void DisconnectRemoteClient(ulong clientId);
+
+        /// <summary>
+        /// Disconnects the local client from the server
+        /// </summary>
+        public abstract void DisconnectLocalClient();
+
+        /// <summary>
+        /// Gets the round trip time for a specific client. This method is optional
+        /// </summary>
+        /// <param name="clientId">The clientId to get the rtt from</param>
+        /// <returns>Returns the round trip time in milliseconds </returns>
+        public abstract ulong GetCurrentRtt(ulong clientId);
+
+        /// <summary>
+        /// Shuts down the transport
+        /// </summary>
+        public abstract void Shutdown();
+
+        /// <summary>
+        /// Initializes the transport
+        /// </summary>
+        public abstract void Init();
+    }
+}