CHANGED TO MIRROR

Assets/Mirror/Runtime/Transport/KCP/kcp2k/kcp/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("kcp2k.Tests")]

Assets/Mirror/Runtime/Transport/KCP/kcp2k/kcp/AssemblyInfo.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: aec6a15ac7bd43129317ea1f01f19782
+timeCreated: 1602665988

Assets/Mirror/Runtime/Transport/KCP/kcp2k/kcp/Kcp.cs.meta

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

Assets/Mirror/Runtime/Transport/KCP/kcp2k/kcp/Pool.cs

@@ -0,0 +1,46 @@
+// Pool to avoid allocations (from libuv2k & Mirror)
+using System;
+using System.Collections.Generic;
+
+namespace kcp2k
+{
+    public class Pool<T>
+    {
+        // Mirror is single threaded, no need for concurrent collections
+        readonly Stack<T> objects = new Stack<T>();
+
+        // some types might need additional parameters in their constructor, so
+        // we use a Func<T> generator
+        readonly Func<T> objectGenerator;
+
+        // some types might need additional cleanup for returned objects
+        readonly Action<T> objectResetter;
+
+        public Pool(Func<T> objectGenerator, Action<T> objectResetter, int initialCapacity)
+        {
+            this.objectGenerator = objectGenerator;
+            this.objectResetter = objectResetter;
+
+            // allocate an initial pool so we have fewer (if any)
+            // allocations in the first few frames (or seconds).
+            for (int i = 0; i < initialCapacity; ++i)
+                objects.Push(objectGenerator());
+        }
+
+        // take an element from the pool, or create a new one if empty
+        public T Take() => objects.Count > 0 ? objects.Pop() : objectGenerator();
+
+        // return an element to the pool
+        public void Return(T item)
+        {
+            objectResetter(item);
+            objects.Push(item);
+        }
+
+        // clear the pool
+        public void Clear() => objects.Clear();
+
+        // count to see how many objects are in the pool. useful for tests.
+        public int Count => objects.Count;
+    }
+}

Assets/Mirror/Runtime/Transport/KCP/kcp2k/kcp/Pool.cs.meta

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

Assets/Mirror/Runtime/Transport/KCP/kcp2k/kcp/Segment.cs

@@ -0,0 +1,62 @@
+using System.IO;
+
+namespace kcp2k
+{
+    // KCP Segment Definition
+    internal class Segment
+    {
+        internal uint conv;     // conversation
+        internal uint cmd;      // command, e.g. Kcp.CMD_ACK etc.
+        internal uint frg;      // fragment
+        internal uint wnd;      // window size that the receive can currently receive
+        internal uint ts;       // timestamp
+        internal uint sn;       // serial number
+        internal uint una;
+        internal uint resendts; // resend timestamp
+        internal int rto;
+        internal uint fastack;
+        internal uint xmit;
+
+        // we need an auto scaling byte[] with a WriteBytes function.
+        // MemoryStream does that perfectly, no need to reinvent the wheel.
+        // note: no need to pool it, because Segment is already pooled.
+        // -> MTU as initial capacity to avoid most runtime resizing/allocations
+        internal MemoryStream data = new MemoryStream(Kcp.MTU_DEF);
+
+        // ikcp_encode_seg
+        // encode a segment into buffer
+        internal int Encode(byte[] ptr, int offset)
+        {
+            int offset_ = offset;
+            offset += Utils.Encode32U(ptr, offset, conv);
+            offset += Utils.Encode8u(ptr, offset, (byte)cmd);
+            offset += Utils.Encode8u(ptr, offset, (byte)frg);
+            offset += Utils.Encode16U(ptr, offset, (ushort)wnd);
+            offset += Utils.Encode32U(ptr, offset, ts);
+            offset += Utils.Encode32U(ptr, offset, sn);
+            offset += Utils.Encode32U(ptr, offset, una);
+            offset += Utils.Encode32U(ptr, offset, (uint)data.Position);
+
+            return offset - offset_;
+        }
+
+        // reset to return a fresh segment to the pool
+        internal void Reset()
+        {
+            conv = 0;
+            cmd = 0;
+            frg = 0;
+            wnd = 0;
+            ts = 0;
+            sn = 0;
+            una = 0;
+            rto = 0;
+            xmit = 0;
+            resendts = 0;
+            fastack = 0;
+
+            // keep buffer for next pool usage, but reset length (= bytes written)
+            data.SetLength(0);
+        }
+    }
+}

Assets/Mirror/Runtime/Transport/KCP/kcp2k/kcp/Segment.cs.meta

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

Assets/Mirror/Runtime/Transport/KCP/kcp2k/kcp/Utils.cs

@@ -0,0 +1,76 @@
+using System.Runtime.CompilerServices;
+
+namespace kcp2k
+{
+    public static partial class Utils
+    {
+        // Clamp so we don't have to depend on UnityEngine
+        public static int Clamp(int value, int min, int max)
+        {
+            if (value < min) return min;
+            if (value > max) return max;
+            return value;
+        }
+
+        // encode 8 bits unsigned int
+        public static int Encode8u(byte[] p, int offset, byte c)
+        {
+            p[0 + offset] = c;
+            return 1;
+        }
+
+        // decode 8 bits unsigned int
+        public static int Decode8u(byte[] p, int offset, ref byte c)
+        {
+            c = p[0 + offset];
+            return 1;
+        }
+
+        // encode 16 bits unsigned int (lsb)
+        public static int Encode16U(byte[] p, int offset, ushort w)
+        {
+            p[0 + offset] = (byte)(w >> 0);
+            p[1 + offset] = (byte)(w >> 8);
+            return 2;
+        }
+
+        // decode 16 bits unsigned int (lsb)
+        public static int Decode16U(byte[] p, int offset, ref ushort c)
+        {
+            ushort result = 0;
+            result |= p[0 + offset];
+            result |= (ushort)(p[1 + offset] << 8);
+            c = result;
+            return 2;
+        }
+
+        // encode 32 bits unsigned int (lsb)
+        public static int Encode32U(byte[] p, int offset, uint l)
+        {
+            p[0 + offset] = (byte)(l >> 0);
+            p[1 + offset] = (byte)(l >> 8);
+            p[2 + offset] = (byte)(l >> 16);
+            p[3 + offset] = (byte)(l >> 24);
+            return 4;
+        }
+
+        // decode 32 bits unsigned int (lsb)
+        public static int Decode32U(byte[] p, int offset, ref uint c)
+        {
+            uint result = 0;
+            result |= p[0 + offset];
+            result |= (uint)(p[1 + offset] << 8);
+            result |= (uint)(p[2 + offset] << 16);
+            result |= (uint)(p[3 + offset] << 24);
+            c = result;
+            return 4;
+        }
+
+        // timediff was a macro in original Kcp. let's inline it if possible.
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static int TimeDiff(uint later, uint earlier)
+        {
+            return (int)(later - earlier);
+        }
+    }
+}

Assets/Mirror/Runtime/Transport/KCP/kcp2k/kcp/Utils.cs.meta

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