fishnet installed

Assets/FishNet/Runtime/Managing/Transporting/IntermediateLayer.cs

@@ -0,0 +1,36 @@
+
+using System;
+using UnityEngine;
+
+namespace FishNet.Managing.Transporting
+{
+
+    /// <summary>
+    /// When inherited from this may be used with the TransportManager to alter messages before they are sent and received.
+    /// </summary>
+    public abstract class IntermediateLayer : MonoBehaviour
+    {
+        /// <summary>
+        /// TransportManager associated with this script.
+        /// </summary>
+        public TransportManager TransportManager { get; private set; }
+
+        /// <summary>
+        /// Called when data is received.
+        /// </summary>
+        /// <param name="src">Original data.</param>
+        /// <param name="fromServer">True if receiving from the server, false if from a client.</param>
+        /// <returns>Modified data.</returns>
+        public abstract ArraySegment<byte> HandleIncoming(ArraySegment<byte> src, bool fromServer);
+        /// <summary>
+        /// Called when data is sent.
+        /// </summary>
+        /// <param name="src">Original data.</param>
+        /// <param name="toServer">True if sending to the server, false if to a client.</param>
+        /// <returns>Modified data.</returns>
+        public abstract ArraySegment<byte> HandleOutoing(ArraySegment<byte> src, bool toServer);
+
+        internal void InitializeOnce(TransportManager manager) => TransportManager = manager;
+    }
+
+}

Assets/FishNet/Runtime/Managing/Transporting/IntermediateLayer.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3f8a2e0f9aaea614887f5f7b15350e46
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Managing/Transporting/LatencySimulator.cs

@@ -0,0 +1,376 @@
+using FishNet.Connection;
+using FishNet.Transporting;
+using FishNet.Utility.Performance;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+//Thanks to TiToMoskito originally creating this as a Transport.
+//https://github.com/TiToMoskito/FishyLatency
+namespace FishNet.Managing.Transporting
+{
+    [System.Serializable]
+    public class LatencySimulator
+    {
+        #region Types.
+        /// <summary>
+        /// A message affected by latency.
+        /// </summary>
+        private struct Message
+        {
+            public readonly int ConnectionId;
+            public readonly byte[] Data;
+            public readonly int Length;
+            public readonly float SendTime;
+
+            public Message(int connectionId, ArraySegment<byte> segment, float latency)
+            {
+                this.ConnectionId = connectionId;
+                this.SendTime = (Time.unscaledTime + latency);
+                this.Length = segment.Count;
+                this.Data = ByteArrayPool.Retrieve(this.Length);
+                Buffer.BlockCopy(segment.Array, segment.Offset, this.Data, 0, this.Length);
+            }
+
+            public ArraySegment<byte> GetSegment()
+            {
+                return new ArraySegment<byte>(Data, 0, Length);
+            }
+        }
+        #endregion
+
+        #region Internal.
+        /// <summary>
+        /// True if latency can be simulated.
+        /// </summary>
+        internal bool CanSimulate => (GetEnabled() && (GetLatency() > 0 || GetPacketLost() > 0 || GetOutOfOrder() > 0));
+        #endregion
+
+        #region Serialized
+        [Header("Settings")]
+        /// <summary>
+        /// 
+        /// </summary>
+        [Tooltip("True if latency simulator is enabled.")]
+        [SerializeField]
+        private bool _enabled;
+        /// <summary>
+        /// Gets the enabled value of simulator.
+        /// </summary>
+        public bool GetEnabled() => _enabled;
+        /// <summary>
+        /// Sets the enabled value of simulator.
+        /// </summary>
+        /// <param name="value">New value.</param>
+        public void SetEnabled(bool value)
+        {
+            if (value == _enabled)
+                return;
+
+            _enabled = value;
+            Reset();
+        }
+        /// <summary>
+        /// 
+        /// </summary>
+        [Tooltip("True to add latency on clientHost as well.")]
+        [SerializeField]
+        private bool _simulateHost = true;
+        /// <summary>
+        /// Milliseconds to add between packets. When acting as host this value will be doubled. Added latency will be a minimum of tick rate.
+        /// </summary>
+        [Tooltip("Milliseconds to add between packets. When acting as host this value will be doubled. Added latency will be a minimum of tick rate.")]
+        [Range(0, 60000)]
+        [SerializeField]
+        private long _latency = 0;
+        /// <summary>
+        /// Gets the latency value.
+        /// </summary>
+        /// <returns></returns>
+        public long GetLatency() => _latency;
+        /// <summary>
+        /// Sets a new latency value.
+        /// </summary>
+        /// <param name="value">Latency as milliseconds.</param>
+        public void SetLatency(long value) => _latency = value;
+
+        [Header("Unreliable")]
+        /// <summary>
+        /// Percentage of unreliable packets which should arrive out of order.
+        /// </summary>
+        [Tooltip("Percentage of unreliable packets which should arrive out of order.")]
+        [Range(0f, 1f)]
+        [SerializeField]
+        private double _outOfOrder = 0;
+        /// <summary>
+        /// Out of order chance, 1f is a 100% chance to occur.
+        /// </summary>
+        /// <returns></returns>
+        public double GetOutOfOrder() => _outOfOrder;
+        /// <summary>
+        /// Sets out of order chance. 1f is a 100% chance to occur.
+        /// </summary>
+        /// <param name="value">New Value.</param>
+        public void SetOutOfOrder(double value) => _outOfOrder = value;
+        /// <summary>
+        /// Percentage of packets which should drop.
+        /// </summary>
+        [Tooltip("Percentage of packets which should drop.")]
+        [Range(0, 1)]
+        [SerializeField]
+        private double _packetLoss = 0;
+        /// <summary>
+        /// Gets packet loss chance. 1f is a 100% chance to occur.
+        /// </summary>
+        /// <returns></returns>
+        public double GetPacketLost() => _packetLoss;
+        /// <summary>
+        /// Sets packet loss chance. 1f is a 100% chance to occur.
+        /// </summary>
+        /// <param name="value">New Value.</param>
+        public void SetPacketLoss(double value) => _packetLoss = value;
+        #endregion
+
+        #region Private
+        /// <summary>
+        /// Transport to send data on.
+        /// </summary>
+        private Transport _transport;
+        /// <summary>
+        /// Reliable messages to the server.
+        /// </summary>
+        private List<Message> _toServerReliable = new List<Message>();
+        /// <summary>
+        /// Unreliable messages to the server.
+        /// </summary>
+        private List<Message> _toServerUnreliable = new List<Message>();
+        /// <summary>
+        /// Reliable messages to clients.
+        /// </summary>
+        private List<Message> _toClientReliable = new List<Message>();
+        /// <summary>
+        /// Unreliable messages to clients.
+        /// </summary>
+        private List<Message> _toClientUnreliable = new List<Message>();
+        /// <summary>
+        /// NetworkManager for this instance.
+        /// </summary>
+        private NetworkManager _networkManager;
+        /// <summary>
+        /// Used to generate chances of latency.
+        /// </summary>
+        private readonly System.Random _random = new System.Random();
+        #endregion
+
+        #region Initialization and Unity
+        public void Initialize(NetworkManager manager, Transport transport)
+        {
+            _networkManager = manager;
+            _transport = transport;
+        }
+        #endregion        
+
+        /// <summary>
+        /// Stops both client and server.
+        /// </summary>
+        public void Reset()
+        {
+            bool enabled = GetEnabled();
+            if (_transport != null && enabled)
+            { 
+                IterateAndStore(_toServerReliable);
+                IterateAndStore(_toServerUnreliable);
+                IterateAndStore(_toClientReliable);
+                IterateAndStore(_toClientUnreliable);
+            }
+
+            void IterateAndStore(List<Message> messages)
+            {
+                foreach (Message m in messages)
+                {
+                    _transport.SendToServer((byte)Channel.Reliable, m.GetSegment());
+                    ByteArrayPool.Store(m.Data);
+                }
+            }
+
+            _toServerReliable.Clear();
+            _toServerUnreliable.Clear();
+            _toClientReliable.Clear();
+            _toClientUnreliable.Clear();
+        }
+
+        /// <summary>
+        /// Removes pending or held packets for a connection.
+        /// </summary>
+        /// <param name="conn">Connection to remove pending packets for.</param>
+        public void RemovePendingForConnection(int connectionId)
+        {
+            RemoveFromCollection(_toServerUnreliable);
+            RemoveFromCollection(_toServerUnreliable);
+            RemoveFromCollection(_toClientReliable);
+            RemoveFromCollection(_toClientUnreliable);
+
+            void RemoveFromCollection(List<Message> c)
+            {
+                for (int i = 0; i < c.Count; i++)
+                {
+                    if (c[i].ConnectionId == connectionId)
+                    {
+                        c.RemoveAt(i);
+                        i--;
+                    }
+                }
+            }
+        }
+
+        #region Simulation
+        /// <summary>
+        /// Returns long latency as a float.
+        /// </summary>
+        /// <param name="ms"></param>
+        /// <returns></returns>
+        private float GetLatencyAsFloat()
+        {
+            return (float)(_latency / 1000f);
+        }
+
+        /// <summary>
+        /// Adds a packet for simulation.
+        /// </summary>
+        public void AddOutgoing(byte channelId, ArraySegment<byte> segment, bool toServer = true, int connectionId = -1)
+        {
+            /* If to not simulate for host see if this packet
+             * should be sent normally. */
+            if (!_simulateHost && _networkManager != null && _networkManager.IsHost)
+            {
+                /* If going to the server and is host then
+                 * it must be sent from clientHost. */
+                if (toServer)
+                {
+                    _transport.SendToServer(channelId, segment);
+                    return;
+                }
+                //Not to server, see if going to clientHost.
+                else
+                {
+                    //If connId is the same as clientHost id.
+                    if (_networkManager.ClientManager.Connection.ClientId == connectionId)
+                    {
+                        _transport.SendToClient(channelId, segment, connectionId);
+                        return;
+                    }
+                }
+            }
+
+            List<Message> collection;
+            Channel c = (Channel)channelId;
+
+            if (toServer)
+                collection = (c == Channel.Reliable) ? _toServerReliable : _toServerUnreliable;
+            else
+                collection = (c == Channel.Reliable) ? _toClientReliable : _toClientUnreliable;
+
+            float latency = GetLatencyAsFloat();
+            //If dropping check to add extra latency if reliable, or discard if not.
+            if (DropPacket())
+            {
+                if (c == Channel.Reliable)
+                {
+                    latency += (latency * 0.3f); //add extra for resend.
+                }
+                //If not reliable then return the segment array to pool.
+                else
+                {
+                    return;
+                }
+            }
+
+            Message msg = new Message(connectionId, segment, latency);
+            int count = collection.Count;
+            if (c == Channel.Unreliable && count > 0 && OutOfOrderPacket(c))
+                collection.Insert(count - 1, msg);
+            else
+                collection.Add(msg);
+        }
+
+        /// <summary>
+        /// Simulates pending outgoing packets.
+        /// </summary>
+        /// <param name="toServer">True if sending to the server.</param>
+        public void IterateOutgoing(bool toServer)
+        {
+            if (_transport == null)
+            {
+                Reset();
+                return;
+            }
+
+            if (toServer)
+            {
+                IterateCollection(_toServerReliable, Channel.Reliable);
+                IterateCollection(_toServerUnreliable, Channel.Unreliable);
+            }
+            else
+            {
+                IterateCollection(_toClientReliable, Channel.Reliable);
+                IterateCollection(_toClientUnreliable, Channel.Unreliable);
+            }
+
+            void IterateCollection(List<Message> collection, Channel channel)
+            {
+                byte cByte = (byte)channel;
+                float unscaledTime = Time.unscaledTime;
+
+                int count = collection.Count;
+                int iterations = 0;
+                for (int i = 0; i < count; i++)
+                {
+                    Message msg = collection[i];
+                    //Not enough time has passed.
+                    if (unscaledTime < msg.SendTime)
+                        break;
+
+                    if (toServer)
+                        _transport.SendToServer(cByte, msg.GetSegment());
+                    else
+                        _transport.SendToClient(cByte, msg.GetSegment(), msg.ConnectionId);
+
+                    iterations++;
+                }
+
+                if (iterations > 0)
+                {
+                    for (int i = 0; i < iterations; i++)
+                        ByteArrayPool.Store(collection[i].Data);
+                    collection.RemoveRange(0, iterations);
+                }
+            }
+
+            _transport.IterateOutgoing(toServer);
+        }
+
+        /// <summary>
+        /// Returns if a packet should drop.
+        /// </summary>
+        /// <returns></returns>
+        private bool DropPacket()
+        {
+            return (_packetLoss > 0d && (_random.NextDouble() < _packetLoss));
+        }
+
+        /// <summary>
+        /// Returns if a packet should be out of order.
+        /// </summary>
+        /// <param name="c"></param>
+        /// <returns></returns>
+        private bool OutOfOrderPacket(Channel c)
+        {
+            if (c == Channel.Reliable)
+                return false;
+
+            return (_outOfOrder > 0d && (_random.NextDouble() < _outOfOrder));
+        }
+        #endregion
+    }
+}
+

Assets/FishNet/Runtime/Managing/Transporting/LatencySimulator.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 82bfafe804acb534fbf04c88de6eeed1
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Managing/Transporting/SplitReader.cs

@@ -0,0 +1,99 @@
+using FishNet.Serializing;
+using System;
+using UnityEngine;
+
+namespace FishNet.Managing.Transporting
+{
+
+    internal class SplitReader
+    {
+        #region Private.
+        /// <summary>
+        /// Tick split is for.
+        /// Tick must be a negative value so that it's impossible for the first tick to align.
+        /// </summary>
+        private long _tick = -1;
+        /// <summary>
+        /// Expected number of splits.
+        /// </summary>
+        private int _expectedMessages;
+        /// <summary>
+        /// Number of splits received so far.
+        /// </summary>
+        private ushort _receivedMessages;
+        /// <summary>
+        /// Writer containing split packet combined.
+        /// </summary>
+        private PooledWriter _writer = WriterPool.GetWriter();
+        #endregion
+
+        internal SplitReader()
+        {
+            //Increase capacity to reduce the chance of resizing.
+            _writer.EnsureBufferCapacity(20000);
+        }
+
+        /// <summary>
+        /// Gets split header values.
+        /// </summary>
+        internal void GetHeader(PooledReader reader, out int expectedMessages)
+        {
+            expectedMessages = reader.ReadInt32();
+        }
+
+        /// <summary>
+        /// Combines split data.
+        /// </summary>
+        internal void Write(uint tick, PooledReader reader, int expectedMessages)
+        {
+            //New tick which means new split.
+            if (tick != _tick)
+                Reset(tick, expectedMessages);
+
+            /* This is just a guess as to how large the end
+             * message could be. If the writer is not the minimum
+             * of this length then resize it. */
+            int estimatedBufferSize = (expectedMessages * 1500);
+            if (_writer.Capacity < estimatedBufferSize)
+                _writer.EnsureBufferCapacity(estimatedBufferSize);
+            /* Empty remainder of reader into the writer.
+             * It does not matter if parts of the reader
+             * contain data added after the split because
+             * once the split is fully combined the data
+             * is parsed as though it came in as one message,
+             * which is how data is normally read. */
+            ArraySegment<byte> data = reader.ReadArraySegment(reader.Remaining);
+            _writer.WriteArraySegment(data);
+            _receivedMessages++;
+        }
+
+        /// <summary>
+        /// Returns if all split messages have been received.
+        /// </summary>
+        /// <returns></returns>
+        internal ArraySegment<byte> GetFullMessage()
+        {
+            if (_receivedMessages < _expectedMessages)
+            {
+                return default(ArraySegment<byte>);
+            }
+            else
+            {
+                ArraySegment<byte> segment = _writer.GetArraySegment();
+                Reset();
+                return segment;
+            }
+        }
+
+        private void Reset(uint tick = 0, int expectedMessages = 0)
+        {
+            _tick = tick;
+            _receivedMessages = 0;
+            _expectedMessages = expectedMessages;
+            _writer.Reset();
+        }
+
+    }
+
+
+}

Assets/FishNet/Runtime/Managing/Transporting/SplitReader.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a1c06be1540b77842be35823aa54b19b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Managing/Transporting/TransportManager.QOL.cs

@@ -0,0 +1,65 @@
+using FishNet.Transporting;
+using FishNet.Transporting.Multipass;
+using UnityEngine;
+
+namespace FishNet.Managing.Transporting
+{
+
+    /// <summary>
+    /// Communicates with the Transport to send and receive data.
+    /// </summary>
+    public sealed partial class TransportManager : MonoBehaviour
+    {
+        #region Public.
+        /// <summary>
+        /// Returns IsLocalTransport for the current transport.
+        /// </summary>
+        public bool IsLocalTransport(int connectionId) => (Transport == null) ? false : Transport.IsLocalTransport(connectionId);
+        #endregion
+
+
+        /// <summary>
+        /// Gets transport on index.
+        /// Commonly index will be 0 unless using Multipass.
+        /// </summary>
+        /// <returns></returns>
+        public Transport GetTransport(int index)
+        {
+            //If using multipass try to find the correct transport.
+            if (Transport is Multipass mp)
+            {
+                return mp.GetTransport(index);
+            }
+            //Not using multipass.
+            else
+            {
+                return Transport;
+            }
+        }
+
+        /// <summary>
+        /// Gets transport of type T.
+        /// </summary>
+        /// <returns>Returns the found transport which is of type T. Returns default of T if not found.</returns>
+        public T GetTransport<T>() where T : Transport
+        {
+            //If using multipass try to find the correct transport.
+            if (Transport is Multipass mp)
+            {
+                if (typeof(T) == typeof(Multipass))
+                    return (T)(object)mp;
+                else
+                    return mp.GetTransport<T>();
+            }
+            //Not using multipass.
+            else
+            {
+                if (Transport.GetType() == typeof(T))
+                    return (T)(object)Transport;
+                else
+                    return default(T);
+            }
+        }
+    }
+
+}

Assets/FishNet/Runtime/Managing/Transporting/TransportManager.QOL.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: aac8eab4e511d7e4dbc81eb74aea7f23
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/FishNet/Runtime/Managing/Transporting/TransportManager.cs

@@ -0,0 +1,668 @@
+using FishNet.Connection;
+using FishNet.Managing.Timing;
+using FishNet.Serializing;
+using FishNet.Transporting;
+using FishNet.Transporting.Multipass;
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace FishNet.Managing.Transporting
+{
+
+    /// <summary>
+    /// Communicates with the Transport to send and receive data.
+    /// </summary>
+    [DisallowMultipleComponent]
+    [AddComponentMenu("FishNet/Manager/TransportManager")]
+    public sealed partial class TransportManager : MonoBehaviour
+    {
+        #region Types.
+        private struct DisconnectingClient
+        {
+            public uint Tick;
+            public NetworkConnection Connection;
+
+            public DisconnectingClient(uint tick, NetworkConnection connection)
+            {
+                Tick = tick;
+                Connection = connection;
+            }
+        }
+        #endregion
+
+        #region Public.
+        /// <summary>
+        /// Called before IterateOutgoing has started.
+        /// </summary>
+        internal event Action OnIterateOutgoingStart;
+        /// <summary>
+        /// Called after IterateOutgoing has completed.
+        /// </summary>
+        internal event Action OnIterateOutgoingEnd;
+        /// <summary>
+        /// Called before IterateIncoming has started. True for on server, false for on client.
+        /// </summary>
+        internal event Action<bool> OnIterateIncomingStart;
+        /// <summary>
+        /// Called after IterateIncoming has completed. True for on server, false for on client.
+        /// </summary>
+        internal event Action<bool> OnIterateIncomingEnd;
+        /// <summary>
+        /// The current Transport being used.
+        /// </summary>
+        [Tooltip("The current Transport being used.")]
+        public Transport Transport;
+        #endregion
+
+        #region Serialized.
+        /// <summary>
+        /// Layer used to modify data before it is sent or received.
+        /// </summary>
+        [Tooltip("Layer used to modify data before it is sent or received.")]
+        [SerializeField]
+        private IntermediateLayer _intermediateLayer;
+        /// <summary>
+        /// 
+        /// </summary>
+        [Tooltip("Latency simulation settings.")]
+        [SerializeField]
+        private LatencySimulator _latencySimulator = new LatencySimulator();
+        /// <summary>
+        /// Latency simulation settings.
+        /// </summary>
+        public LatencySimulator LatencySimulator
+        {
+            get
+            {
+                //Shouldn't ever be null unless the user nullifies it.
+                if (_latencySimulator == null)
+                    _latencySimulator = new LatencySimulator();
+                return _latencySimulator;
+            }
+        }
+        #endregion
+
+        #region Private.
+        /// <summary>
+        /// NetworkConnections on the server which have to send data to clients.
+        /// </summary>
+        private List<NetworkConnection> _dirtyToClients = new List<NetworkConnection>();
+        /// <summary>
+        /// PacketBundles to send to the server.
+        /// </summary>
+        private List<PacketBundle> _toServerBundles = new List<PacketBundle>();
+        /// <summary>
+        /// NetworkManager handling this TransportManager.
+        /// </summary>
+        private NetworkManager _networkManager;
+        /// <summary>
+        /// Clients which are pending disconnects.
+        /// </summary>
+        private List<DisconnectingClient> _disconnectingClients = new List<DisconnectingClient>();
+        /// <summary>
+        /// Lowest MTU of all transports for channels.
+        /// </summary>
+        private int[] _lowestMtu;
+        #endregion
+
+        #region Consts.
+        /// <summary>
+        /// Number of bytes sent for PacketId.
+        /// </summary>
+        public const byte PACKET_ID_BYTES = 2;
+        /// <summary>
+        /// Number of bytes sent for ObjectId.
+        /// </summary>
+        public const byte OBJECT_ID_BYTES = 2;
+        /// <summary>
+        /// Number of bytes sent for ComponentIndex.
+        /// </summary>
+        public const byte COMPONENT_INDEX_BYTES = 1;
+        /// <summary>
+        /// Number of bytes sent for Tick.
+        /// </summary>
+        public const byte TICK_BYTES = 4;
+        /// <summary>
+        /// Number of bytes sent to indicate split count.
+        /// </summary>
+        private const byte SPLIT_COUNT_BYTES = 4;
+        /// <summary>
+        /// Number of bytes required for split data. 
+        /// </summary>
+        public const byte SPLIT_INDICATOR_SIZE = (PACKET_ID_BYTES + SPLIT_COUNT_BYTES);
+        /// <summary>
+        /// Number of channels supported.
+        /// </summary>
+        public const byte CHANNEL_COUNT = 2;
+        #endregion
+
+        /// <summary>
+        /// Initializes this script for use.
+        /// </summary>
+        internal void InitializeOnce_Internal(NetworkManager manager)
+        {
+            _networkManager = manager;
+            /* If transport isn't specified then add default
+             * transport. */
+            if (Transport == null && !gameObject.TryGetComponent<Transport>(out Transport))
+                Transport = gameObject.AddComponent<FishNet.Transporting.Tugboat.Tugboat>();
+
+            Transport.Initialize(_networkManager, 0);
+            //Cache lowest Mtus.
+            _lowestMtu = new int[CHANNEL_COUNT];
+            for (byte i = 0; i < CHANNEL_COUNT; i++)
+                _lowestMtu[i] = GetLowestMTU(i);
+
+            InitializeToServerBundles();
+            if (_intermediateLayer != null)
+                _intermediateLayer.InitializeOnce(this);
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+            _latencySimulator.Initialize(manager, Transport);
+#endif
+        }
+
+        /// <summary>
+        /// Sets a connection from server to client dirty.
+        /// </summary>
+        /// <param name="conn"></param>
+        internal void ServerDirty(NetworkConnection conn)
+        {
+            _dirtyToClients.Add(conn);
+        }
+
+        /// <summary>
+        /// Initializes ToServerBundles for use.
+        /// </summary>
+        private void InitializeToServerBundles()
+        {
+            /* For ease of use FishNet will always have
+             * only two channels, reliable and unreliable. 
+             * Even if the transport only supports reliable
+             * also setup for unreliable. */
+            for (byte i = 0; i < CHANNEL_COUNT; i++)
+            {
+                int mtu = GetLowestMTU(i);
+                _toServerBundles.Add(new PacketBundle(_networkManager, mtu));
+            }
+        }
+
+        #region GetMTU.
+        /* Returned MTUs are always -1 to allow an extra byte
+         * to specify channel where certain transports do
+         * not allow or provide channel information. */
+        /// <summary>
+        /// Returns the lowest MTU for a channel. When using multipass this will evaluate all transports within Multipass.
+        /// </summary>
+        /// <param name="channel"></param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetLowestMTU(byte channel)
+        {
+            //Use cached if available.
+            if (_lowestMtu[channel] > 0)
+                return _lowestMtu[channel];
+
+            if (Transport is Multipass mp)
+            {
+                int? lowestMtu = null;
+                foreach (Transport t in mp.Transports)
+                {
+                    int thisMtu = t.GetMTU(channel);
+                    if (lowestMtu == null || thisMtu < lowestMtu.Value)
+                        lowestMtu = thisMtu;
+                }
+
+                //If lowest was not changed return unset.
+                if (lowestMtu == null)
+                {
+                    return -1;
+                }
+                else
+                {
+                    int mtu = lowestMtu.Value;
+                    if (mtu >= 0)
+                        mtu -= 1;
+                    return mtu;
+                }
+            }
+            else
+            {
+                return GetMTU(channel);
+            }
+        }
+        /// <summary>
+        /// Gets MTU on the current transport for channel.
+        /// </summary>
+        /// <param name="channel">Channel to get MTU of.</param>
+        /// <returns></returns>
+        public int GetMTU(byte channel)
+        {
+            int mtu = Transport.GetMTU(channel);
+            if (mtu >= 0)
+                mtu -= 1;
+            return mtu;
+        }
+        /// <summary>
+        /// Gets MTU on the transportIndex for channel. This requires use of Multipass.
+        /// </summary>
+        /// <param name="transportIndex">Index of the transport to get the MTU on.</param>
+        /// <param name="channel">Channel to get MTU of.</param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetMTU(int transportIndex, byte channel)
+        {
+            if (Transport is Multipass mp)
+            {
+                int mtu = mp.GetMTU(channel, transportIndex);
+                if (mtu >= 0)
+                    mtu -= 1;
+                return mtu;
+            }
+            //Using first/only transport.
+            else if (transportIndex == 0)
+            {
+                return GetMTU(channel);
+            }
+            //Unhandled.
+            else
+            {
+                _networkManager.LogWarning($"MTU cannot be returned with transportIndex because {typeof(Multipass).Name} is not in use.");
+                return -1;
+            }
+        }
+        /// <summary>
+        /// Gets MTU on the transport type for channel. This requires use of Multipass.
+        /// </summary>
+        /// <typeparam name="T">Tyep of transport to use.</typeparam>
+        /// <param name="channel">Channel to get MTU of.</param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public int GetMTU<T>(byte channel) where T : Transport
+        {
+            Transport transport = GetTransport<T>();
+            if (transport != null)
+            {
+                int mtu = transport.GetMTU(channel);
+                if (mtu >= 0)
+                    mtu -= 1;
+                return mtu;
+            }
+
+            //Fall through.
+            return -1;
+        }
+        #endregion
+
+        /// <summary>
+        /// Passes received to the intermediate layer.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal ArraySegment<byte> ProcessIntermediateIncoming(ArraySegment<byte> src, bool fromServer)
+        {
+            return (_intermediateLayer == null) ? src : _intermediateLayer.HandleIncoming(src, fromServer);
+        }
+        /// <summary>
+        /// Passes sent to the intermediate layer.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private ArraySegment<byte> ProcessIntermediateOutgoing(ArraySegment<byte> src, bool toServer)
+        {
+            return (_intermediateLayer == null) ? src : _intermediateLayer.HandleOutoing(src, toServer);
+        }
+
+        /// <summary>
+        /// Sends data to a client.
+        /// </summary>
+        /// <param name="channelId">Channel to send on.</param>
+        /// <param name="segment">Data to send.</param>
+        /// <param name="connection">Connection to send to. Use null for all clients.</param>
+        /// <param name="splitLargeMessages">True to split large packets which exceed MTU and send them in order on the reliable channel.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void SendToClient(byte channelId, ArraySegment<byte> segment, NetworkConnection connection, bool splitLargeMessages = true)
+        {
+            segment = ProcessIntermediateOutgoing(segment, false);
+            SetSplitValues(channelId, segment, splitLargeMessages, out int requiredSplitMessages, out int maxSplitMessageSize);
+            SendToClient_Internal(channelId, segment, connection, requiredSplitMessages, maxSplitMessageSize);
+        }
+        private void SendToClient_Internal(byte channelId, ArraySegment<byte> segment, NetworkConnection connection, int requiredSplitMessages, int maxSplitMessageSize)
+        {
+            if (connection == null)
+                return;
+
+            if (requiredSplitMessages > 1)
+                SendSplitData(connection, ref segment, requiredSplitMessages, maxSplitMessageSize);
+            else
+                connection.SendToClient(channelId, segment);
+        }
+
+        /// <summary>
+        /// Sends data to observers.
+        /// </summary>
+        /// <param name="channelId"></param>
+        /// <param name="segment"></param>
+        /// <param name="observers"></param>
+        /// <param name="splitLargeMessages">True to split large packets which exceed MTU and send them in order on the reliable channel.</param>
+        internal void SendToClients(byte channelId, ArraySegment<byte> segment, HashSet<NetworkConnection> observers, HashSet<NetworkConnection> excludedConnections = null, bool splitLargeMessages = true)
+        {
+            segment = ProcessIntermediateOutgoing(segment, false);
+            SetSplitValues(channelId, segment, splitLargeMessages, out int requiredSplitMessages, out int maxSplitMessageSize);
+            SendToClients_Internal(channelId, segment, observers, excludedConnections, requiredSplitMessages, maxSplitMessageSize);
+        }
+        private void SendToClients_Internal(byte channelId, ArraySegment<byte> segment, HashSet<NetworkConnection> observers, HashSet<NetworkConnection> excludedConnections, int requiredSplitMessages, int maxSplitMessageSize)
+        {
+            if (excludedConnections == null || excludedConnections.Count == 0)
+            {
+                foreach (NetworkConnection conn in observers)
+                    SendToClient_Internal(channelId, segment, conn, requiredSplitMessages, maxSplitMessageSize);
+            }
+            else
+            {
+                foreach (NetworkConnection conn in observers)
+                {
+                    if (excludedConnections.Contains(conn))
+                        continue;
+                    SendToClient_Internal(channelId, segment, conn, requiredSplitMessages, maxSplitMessageSize);
+                }
+            }
+        }
+
+
+
+        /// <summary>
+        /// Sends data to all clients.
+        /// </summary>
+        /// <param name="channelId">Channel to send on.</param>
+        /// <param name="segment">Data to send.</param>
+        /// <param name="splitLargeMessages">True to split large packets which exceed MTU and send them in order on the reliable channel.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void SendToClients(byte channelId, ArraySegment<byte> segment, bool splitLargeMessages = true)
+        {
+            segment = ProcessIntermediateOutgoing(segment, false);
+            SetSplitValues(channelId, segment, splitLargeMessages, out int requiredSplitMessages, out int maxSplitMessageSize);
+            SendToClients_Internal(channelId, segment, requiredSplitMessages, maxSplitMessageSize);
+        }
+        private void SendToClients_Internal(byte channelId, ArraySegment<byte> segment, int requiredSplitMessages, int maxSplitMessageSize)
+        {
+            /* Rather than buffer the message once and send to every client
+             * it must be queued into every client. This ensures clients
+             * receive the message in order of other packets being
+             * delivered to them. */
+            foreach (NetworkConnection conn in _networkManager.ServerManager.Clients.Values)
+                SendToClient_Internal(channelId, segment, conn, requiredSplitMessages, maxSplitMessageSize);
+        }
+
+        /// <summary>
+        /// Sends data to the server.
+        /// </summary>
+        /// <param name="channelId">Channel to send on.</param>
+        /// <param name="segment">Data to send.</param>
+        /// <param name="splitLargeMessages">True to split large packets which exceed MTU and send them in order on the reliable channel.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void SendToServer(byte channelId, ArraySegment<byte> segment, bool splitLargeMessages = true)
+        {
+            segment = ProcessIntermediateOutgoing(segment, true);
+            SetSplitValues(channelId, segment, splitLargeMessages, out int requiredSplitMessages, out int maxSplitMessageSize);
+            SendToServer_Internal(channelId, segment, requiredSplitMessages, maxSplitMessageSize);
+        }
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void SendToServer_Internal(byte channelId, ArraySegment<byte> segment, int requiredSplitMessages, int maxSplitMessageSize)
+        {
+            if (channelId >= _toServerBundles.Count)
+                channelId = (byte)Channel.Reliable;
+
+            if (requiredSplitMessages > 1)
+                SendSplitData(null, ref segment, requiredSplitMessages, maxSplitMessageSize);
+            else
+                _toServerBundles[channelId].Write(segment);
+        }
+
+        #region Splitting.     
+        /// <summary>
+        /// Checks if a message can be split and outputs split information if so.
+        /// </summary>
+        private void SetSplitValues(byte channelId, ArraySegment<byte> segment, bool split, out int requiredSplitMessages, out int maxSplitMessageSize)
+        {
+            if (!split)
+            {
+                requiredSplitMessages = 0;
+                maxSplitMessageSize = 0;
+            }
+            else
+            {
+                SplitRequired(channelId, segment.Count, out requiredSplitMessages, out maxSplitMessageSize);
+            }
+        }
+        /// <summary>
+        /// True if data must be split.
+        /// </summary>
+        /// <param name="channelId"></param>
+        /// <param name="segmentSize"></param>
+        /// <returns></returns>
+        private bool SplitRequired(byte channelId, int segmentSize, out int requiredMessages, out int maxMessageSize)
+        {
+            maxMessageSize = GetLowestMTU(channelId) - (TransportManager.TICK_BYTES + SPLIT_INDICATOR_SIZE);
+            requiredMessages = Mathf.CeilToInt((float)segmentSize / maxMessageSize);
+
+            return (requiredMessages > 1);
+        }
+
+        /// <summary>
+        /// Splits data going to which is too large to fit within the transport MTU.
+        /// </summary>
+        /// <param name="conn">Connection to send to. If null data will be sent to the server.</param>
+        /// <returns>True if data was sent split.</returns>
+        private void SendSplitData(NetworkConnection conn, ref ArraySegment<byte> segment, int requiredMessages, int maxMessageSize)
+        {
+            if (requiredMessages <= 1)
+            {
+                _networkManager.LogError($"SendSplitData was called with {requiredMessages} required messages. This method should only be called if messages must be split into 2 pieces or more.");
+                return;
+            }
+
+            byte channelId = (byte)Channel.Reliable;
+            PooledWriter headerWriter = WriterPool.GetWriter();
+            headerWriter.WritePacketId(PacketId.Split);
+            headerWriter.WriteInt32(requiredMessages);
+            ArraySegment<byte> headerSegment = headerWriter.GetArraySegment();
+
+            int writeIndex = 0;
+            bool firstWrite = true;
+            //Send to connection until everything is written.
+            while (writeIndex < segment.Count)
+            {
+                int headerReduction = 0;
+                if (firstWrite)
+                {
+                    headerReduction = headerSegment.Count;
+                    firstWrite = false;
+                }
+                int chunkSize = Mathf.Min(segment.Count - writeIndex - headerReduction, maxMessageSize);
+                //Make a new array segment for the chunk that is getting split.
+                ArraySegment<byte> splitSegment = new ArraySegment<byte>(
+                    segment.Array, segment.Offset + writeIndex, chunkSize);
+
+                //If connection is specified then it's going to a client.
+                if (conn != null)
+                {
+                    conn.SendToClient(channelId, headerSegment, true);
+                    conn.SendToClient(channelId, splitSegment);
+                }
+                //Otherwise it's going to the server.
+                else
+                {
+                    _toServerBundles[channelId].Write(headerSegment, true);
+                    _toServerBundles[channelId].Write(splitSegment, false);
+                }
+
+                writeIndex += chunkSize;
+            }
+
+            headerWriter.Dispose();
+        }
+        #endregion
+
+
+        /// <summary>
+        /// Processes data received by the socket.
+        /// </summary>
+        /// <param name="server">True to process data received on the server.</param>
+        internal void IterateIncoming(bool server)
+        {
+            OnIterateIncomingStart?.Invoke(server);
+            Transport.IterateIncoming(server);
+            OnIterateIncomingEnd?.Invoke(server);
+        }
+
+        /// <summary>
+        /// Processes data to be sent by the socket.
+        /// </summary>
+        /// <param name="toServer">True to process data received on the server.</param>
+        internal void IterateOutgoing(bool toServer)
+        {
+            OnIterateOutgoingStart?.Invoke();
+            int channelCount = CHANNEL_COUNT;
+            ulong sentBytes = 0;
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+            bool latencySimulatorEnabled = LatencySimulator.CanSimulate;
+#endif
+            /* If sending to the client. */
+            if (!toServer)
+            {
+                TimeManager tm = _networkManager.TimeManager;
+                uint localTick = tm.LocalTick;
+                //Write any dirty syncTypes.
+                _networkManager.ServerManager.Objects.WriteDirtySyncTypes();
+
+                int dirtyCount = _dirtyToClients.Count;
+
+                //Run through all dirty connections to send data to.
+                for (int z = 0; z < dirtyCount; z++)
+                {
+                    NetworkConnection conn = _dirtyToClients[z];
+                    if (conn == null || !conn.IsValid)
+                        continue;
+
+                    //Get packets for every channel.
+                    for (byte channel = 0; channel < channelCount; channel++)
+                    {
+                        if (conn.GetPacketBundle(channel, out PacketBundle pb))
+                        {
+                            for (int i = 0; i < pb.WrittenBuffers; i++)
+                            {
+                                //Length should always be more than 0 but check to be safe.
+                                if (pb.GetBuffer(i, out ByteBuffer bb))
+                                {
+                                    ArraySegment<byte> segment = new ArraySegment<byte>(bb.Data, 0, bb.Length);
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+                                    if (latencySimulatorEnabled)
+                                        _latencySimulator.AddOutgoing(channel, segment, false, conn.ClientId);
+                                    else
+#endif
+                                        Transport.SendToClient(channel, segment, conn.ClientId);
+                                    sentBytes += (ulong)segment.Count;
+                                }
+                            }
+
+                            pb.Reset();
+                        }
+                    }
+
+                    /* When marked as disconnecting data will still be sent
+                     * this iteration but the connection will be marked as invalid.
+                     * This will prevent future data from going out/coming in.
+                     * Also the connection will be added to a disconnecting collection
+                     * so it will it disconnected briefly later to allow data from
+                     * this tick to send. */
+                    if (conn.Disconnecting)
+                    {
+                        uint requiredTicks = tm.TimeToTicks(0.1d, TickRounding.RoundUp);
+                        /* Require 100ms or 2 ticks to pass
+                         * before disconnecting to allow for the
+                         * higher chance of success that remaining
+                         * data is sent. */
+                        requiredTicks = Math.Max(requiredTicks, 2);
+                        _disconnectingClients.Add(new DisconnectingClient(requiredTicks + localTick, conn));
+                    }
+
+                    conn.ResetServerDirty();
+                }
+
+                //Iterate disconnects.
+                for (int i = 0; i < _disconnectingClients.Count; i++)
+                {
+                    DisconnectingClient dc = _disconnectingClients[i];
+                    if (localTick >= dc.Tick)
+                    {
+                        _networkManager.TransportManager.Transport.StopConnection(dc.Connection.ClientId, true);
+                        _disconnectingClients.RemoveAt(i);
+                        i--;
+                    }
+                }
+
+                _networkManager.StatisticsManager.NetworkTraffic.LocalServerSentData(sentBytes);
+
+                if (dirtyCount == _dirtyToClients.Count)
+                    _dirtyToClients.Clear();
+                else if (dirtyCount > 0)
+                    _dirtyToClients.RemoveRange(0, dirtyCount);
+            }
+            /* If sending to the server. */
+            else
+            {
+                for (byte channel = 0; channel < channelCount; channel++)
+                {
+                    if (PacketBundle.GetPacketBundle(channel, _toServerBundles, out PacketBundle pb))
+                    {
+                        for (int i = 0; i < pb.WrittenBuffers; i++)
+                        {
+                            if (pb.GetBuffer(i, out ByteBuffer bb))
+                            {
+                                ArraySegment<byte> segment = new ArraySegment<byte>(bb.Data, 0, bb.Length);
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+                                if (latencySimulatorEnabled)
+                                    _latencySimulator.AddOutgoing(channel, segment);
+                                else
+#endif
+                                    Transport.SendToServer(channel, segment);
+                                sentBytes += (ulong)segment.Count;
+                            }
+                        }
+                        pb.Reset();
+                    }
+                }
+
+                _networkManager.StatisticsManager.NetworkTraffic.LocalClientSentData(sentBytes);
+            }
+
+#if UNITY_EDITOR || DEVELOPMENT_BUILD
+            if (latencySimulatorEnabled)
+                _latencySimulator.IterateOutgoing(toServer);
+#endif
+
+            Transport.IterateOutgoing(toServer);
+            OnIterateOutgoingEnd?.Invoke();
+        }
+
+        #region Editor.
+#if UNITY_EDITOR
+        private void OnValidate()
+        {
+            if (Transport == null)
+                Transport = GetComponent<Transport>();
+
+            /* Update enabled state to force a reset if needed.
+             * This may be required if the user checked the enabled
+             * tick box at runtime. If enabled value didn't change
+             * then the Get will be the same as the Set and nothing
+             * will happen. */
+            _latencySimulator.SetEnabled(_latencySimulator.GetEnabled());
+        }
+#endif
+        #endregion
+
+    }
+
+
+}

Assets/FishNet/Runtime/Managing/Transporting/TransportManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 34e4a322dca349547989b14021da4e23
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {fileID: 2800000, guid: bf9191e2e07d29749bca3a1ae44e4bc8, type: 3}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: