Fixed CeilingExact functions

Added sign bit constants for all signed types
Fixed Length
Fixed Grow?
Added Grow call where necessary
Added some necessary methods

Author: GabrielTofvesson

MLAPI/NetworkingManagerComponents/Binary/Arithmetic.cs

@@ -2,15 +2,36 @@
 {
     public static class Arithmetic
     {
+        // Sign bits for different data types
+        public const long  SIGN_BIT_64 = -9223372036854775808;
+        public const int   SIGN_BIT_32 = -2147483648;
+        public const short SIGN_BIT_16 = -32768;
+        public const sbyte SIGN_BIT_8  = -128;
+
+        // Ceiling function that doesn't deal with floating point values
         public static ulong CeilingExact(ulong u1, ulong u2) => (u1 / u2) + (u1 % u2 == 0 ? 0UL : 1UL);
-        public static long CeilingExact(long u1, long u2) => (u1 / u2) + (u1 % u2 == 0 ? 0L : 1L);
+        public static long CeilingExact(long u1, long u2) => (u1 / u2) + (u1 % u2 == 0 ? 0L : 1L | ((u1&SIGN_BIT_64)^(u2&SIGN_BIT_64)));
         public static uint CeilingExact(uint u1, uint u2) => (u1 / u2) + (u1 % u2 == 0 ? 0U : 1U);
-        public static int CeilingExact(int u1, int u2) => (u1 / u2) + (u1 % u2 == 0 ? 0 : 1);
+        public static int CeilingExact(int u1, int u2) => (u1 / u2) + (u1 % u2 == 0 ? 0 : 1 | ((u1 & SIGN_BIT_32) ^ (u2 & SIGN_BIT_32)));
         public static ushort CeilingExact(ushort u1, ushort u2) => (ushort)((u1 / u2) + (u1 % u2 == 0 ? 0 : 1));
-        public static short CeilingExact(short u1, short u2) => (short)((u1 / u2) + (u1 % u2 == 0 ? 0 : 1));
+        public static short CeilingExact(short u1, short u2) => (short)((u1 / u2) + (u1 % u2 == 0 ? 0 : 1 | ((u1 & SIGN_BIT_32) ^ (u2 & SIGN_BIT_32))));
         public static byte CeilingExact(byte u1, byte u2) => (byte)((u1 / u2) + (u1 % u2 == 0 ? 0 : 1));
-        public static sbyte CeilingExact(sbyte u1, sbyte u2) => (sbyte)((u1 / u2) + (u1 % u2 == 0 ? 0 : 1));
+        public static sbyte CeilingExact(sbyte u1, sbyte u2) => (sbyte)((u1 / u2) + (u1 % u2 == 0 ? 0 : 1 | ((u1 & SIGN_BIT_32) ^ (u2 & SIGN_BIT_32))));
+
+        // ZigZag
         public static ulong ZigZagEncode(long value) => (ulong)((value >> 63) ^ (value << 1));
         public static long ZigZagDecode(ulong value) => (((long)(value >> 1) & 0x7FFFFFFFFFFFFFFFL) ^ ((long)(value << 63) >> 63));
+
+        // Var int helper stuff
+        public static int VarIntSize(ulong value) =>
+                value <= 240 ? 1 :
+                value <= 2287 ? 2 :
+                value <= 67823 ? 3 :
+                value <= 16777215 ? 4 :
+                value <= 4294967295 ? 5 :
+                value <= 1099511627775 ? 6 :
+                value <= 281474976710655 ? 7 :
+                value <= 72057594037927935 ? 8 :
+                9;
     }
 }

MLAPI/NetworkingManagerComponents/Binary/BitStream.cs

@@ -9,16 +9,14 @@ namespace MLAPI.NetworkingManagerComponents.Binary
 {
     public sealed class BitStream : Stream
     {
-        private const long SIGN_BIT = -9223372036854775808;
-
-
         private readonly double growthFactor;
         private readonly byte[] target;
 
         public BitStream(byte[] target, double growthFactor = 2.0)
         {
             this.target = target;
             this.growthFactor = growthFactor <= 1 ? 1.5 : growthFactor;
+            BitLength = (ulong)target.LongLength << 3;
         }
 
         public override bool CanRead => BitPosition < (ulong) target.LongLength;
@@ -27,8 +25,9 @@ public BitStream(byte[] target, double growthFactor = 2.0)
 
         public override bool CanWrite => true;
 
-        public override long Length => (long) (BitLength>>3);
+        public override long Length => (long) ((BitLength>>3) + ((BitLength&1UL)|((BitLength>>1)&1UL)|((BitLength>>2)&1UL))); // Optimized CeilingExact
 
+        private long BitWriteIndex { get => (long)((BitPosition >> 3) + ((BitPosition & 1UL) | ((BitPosition >> 1) & 1UL) | ((BitPosition >> 2) & 1UL))); }
         public override long Position { get => (long)(BitPosition>>3); set => BitPosition = (ulong)value << 3; }
         public ulong BitPosition { get; set; }
         public ulong BitLength { get; private set; }
@@ -60,9 +59,9 @@ public override long Seek(long offset, SeekOrigin origin)
                     origin == SeekOrigin.Current ?
                         offset > 0 ?
                             Math.Min(BitPosition + ((ulong)offset << 3), (ulong)target.Length << 3) :
-                            (offset ^ SIGN_BIT) > Position ?
+                            (offset ^ SIGN_BIT_64) > Position ?
                                 0UL :
-                                BitPosition - (ulong)((offset ^ SIGN_BIT) << 3) :
+                                BitPosition - (ulong)((offset ^ SIGN_BIT_64) << 3) :
                     origin == SeekOrigin.Begin ?
                         (ulong)Math.Max(0, offset) << 3 :
                         (ulong)Math.Max(target.Length - offset, 0) << 3
@@ -93,7 +92,7 @@ public override void Write(byte[] buffer, int offset, int count)
             }
         }
 
-        private void Grow(int newContent) => SetLength(target.LongLength * (long)Math.Pow(growthFactor, CeilingExact(newContent, target.Length)));
+        private void Grow(int newContent) => SetLength(Math.Max(target.LongLength, 1) * (long)Math.Pow(growthFactor, CeilingExact(newContent, Math.Max(target.Length, 1))));
 
         public void WriteBit(bool bit)
         {
@@ -138,6 +137,8 @@ public void WriteUInt64(ulong value)
         public void WriteInt64Packed(long value) => WriteUInt64(ZigZagEncode(value));
         public void WriteUInt64Packed(ulong value)
         {
+            int grow = VarIntSize(value);
+            if (BitWriteIndex + grow >= target.LongLength) Grow(grow);
             if (value <= 240) WriteULongByte(value);
             else if (value <= 2287)
             {
@@ -206,6 +207,7 @@ public ulong ReadUInt64Packed()
             while (hdr > ++cmp) res |= (ulong)_ReadByte() << (cmp << 3);
             return res;
         }
+        public bool ReadBit() => (target[Position] & (1 << (int)(BitPosition++ & 7))) != 0;
 
 
         private void WriteULongByteMisaligned(ulong value) => WriteMisaligned((byte)value);
@@ -222,12 +224,15 @@ private void WriteMisaligned(byte value)
         private void WriteULongByte(ulong byteValue) => WriteByte((byte)byteValue);
         public override void WriteByte(byte value)
         {
+            if (Position == target.LongLength) Grow(1);
             if (BitAligned)
             {
                 target[Position] = value;
                 ++Position;
             }
             else WriteMisaligned(value);
         }
+
+        public byte[] GetBuffer() => target;
     }
 }