Out with MagicOnion, in with LiteNetLib

Removed MagicOnion
Added LiteNetLib
Created client and server abstractions
Fixed serialization bugs

Assets/Scripts/ServerShared/NIH/LiteNetLib/NetPacketPool.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Threading;
+
+namespace LiteNetLib
+{
+    internal sealed class NetPacketPool
+    {
+        private readonly NetPacket[] _pool = new NetPacket[NetConstants.PacketPoolSize];
+        private readonly ReaderWriterLockSlim _lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
+        private int _count;
+
+        public NetPacket GetWithData(PacketProperty property, byte[] data, int start, int length)
+        {
+            int headerSize = NetPacket.GetHeaderSize(property);
+            NetPacket packet = GetPacket(length + headerSize);
+            packet.Property = property;
+            Buffer.BlockCopy(data, start, packet.RawData, headerSize, length);
+            return packet;
+        }
+
+        //Get packet with size
+        public NetPacket GetWithProperty(PacketProperty property, int size)
+        {
+            NetPacket packet = GetPacket(size + NetPacket.GetHeaderSize(property));
+            packet.Property = property;
+            return packet;
+        }
+
+        public NetPacket GetWithProperty(PacketProperty property)
+        {
+            NetPacket packet = GetPacket(NetPacket.GetHeaderSize(property));
+            packet.Property = property;
+            return packet;
+        }
+
+        public NetPacket GetPacket(int size)
+        {
+            if (size <= NetConstants.MaxPacketSize)
+            {
+                NetPacket packet = null;
+                _lock.EnterUpgradeableReadLock();
+                if (_count > 0)
+                {
+                    _lock.EnterWriteLock();
+                    _count--;
+                    packet = _pool[_count];
+                    _pool[_count] = null;
+                    _lock.ExitWriteLock();
+                }
+                _lock.ExitUpgradeableReadLock();
+                if (packet != null)
+                {
+                    packet.Size = (ushort)size;
+                    if (packet.RawData.Length < size)
+                        packet.RawData = new byte[size];
+                    return packet;
+                }
+            }
+            return new NetPacket(size);
+        }
+
+        public void Recycle(NetPacket packet)
+        {
+            if (packet.RawData.Length > NetConstants.MaxPacketSize)
+            {
+                //Dont pool big packets. Save memory
+                return;
+            }
+
+            //Clean fragmented flag
+            packet.RawData[0] = 0;
+
+            _lock.EnterUpgradeableReadLock();
+            if (_count == NetConstants.PacketPoolSize)
+            {
+                _lock.ExitUpgradeableReadLock();
+                return;
+            }
+            _lock.EnterWriteLock();
+            _pool[_count] = packet;
+            _count++;
+            _lock.ExitWriteLock();
+            _lock.ExitUpgradeableReadLock();
+        }
+    }
+}