using System;

using System.Numerics;          

public class Program

{

    public static void Main()

    {

        var bufferData = NetBuffer.Create(32);

        NetBuffer.AddUShort(ref bufferData, 23);

        var val = NetBuffer.ReadUShort(ref bufferData);

        Console.WriteLine(val);

    }

}

​

​

public struct NetBufferData

{

        public int readPosition;

        public int nextPosition;

        public uint[] chunks;

}

    public class NetBuffer

    {

​

        private const int defaultCapacity = 375; // 375 * 4 = 1500 bytes

        private const int stringLengthBits = 8;

        private const int stringLengthMax = (1 << stringLengthBits) - 1; // 255

        private const int bitsASCII = 7;

        private const int growFactor = 2;

        private const int minGrow = 1;

​

​

        public static NetBufferData Create(ushort id, int capacity = defaultCapacity)

        {

            return new NetBufferData()

            {

                readPosition = 0,

                nextPosition = 0,

                chunks = new uint[capacity]

            };

        }

​

        public static void AddUShort(ref NetBufferData data, ushort value)

        {

            AddUInt(ref data, value);

        }

        public static void AddUInt(ref NetBufferData data, uint value)

        {

            uint buffer = 0x0u;

​

            do

            {

                buffer = value & 0x7Fu;

                value >>= 7;

​

                if (value > 0)

                    buffer |= 0x80u;

​

                Add(ref data, 8, buffer);

            }

​

            while (value > 0);

        }

        public static void Add(ref NetBufferData data, int numBits, uint value)

        {

​

            int index = data.nextPosition >> 5;

            int used = data.nextPosition & 0x0000001F;

​

​

​

​

​

            ulong chunkMask = ((1UL << used) - 1);

            ulong scratch = data.chunks[index] & chunkMask;

            ulong result = scratch | ((ulong)value << used);

​

            data.chunks[index] = (uint)result;

            data.chunks[index + 1] = (uint)(result >> 32);

            data.nextPosition += numBits;

​

        }

        public static ushort ReadUShort(ref NetBufferData data)

        {

            return (ushort)ReadUInt(ref data);

        }

        public static uint ReadUInt(ref NetBufferData data)

        {

            uint buffer = 0x0u;

            uint value = 0x0u;

            int shift = 0;

​

            do

            {

                buffer = Read(ref data, 8);

​

                value |= (buffer & 0x7Fu) << shift;

                shift += 7;

            }

​

            while ((buffer & 0x80u) > 0);

​

            return value;

        }

        public static uint Read(ref NetBufferData data, int numBits)

        {

            uint result = Peek(ref data, numBits);

​

            data.readPosition += numBits;

​

            return result;

        }

        public static uint Peek(ref NetBufferData data, int numBits)

        {

​

            int index = data.readPosition >> 5;

            int used = data.readPosition & 0x0000001F;

​

            ulong chunkMask = ((1UL << numBits) - 1) << used;

            ulong scratch = (ulong)data.chunks[index];

​

            if ((index + 1) < data.chunks.Length)

                scratch |= (ulong)data.chunks[index + 1] << 32;

​

            ulong result = (scratch & chunkMask) >> used;

​

            return (uint)result;

        }

    }

​