Fixed WriteInt64

Author: GabrielTofvesson

MLAPI/NetworkingManagerComponents/Binary/BitStream.cs

@@ -64,7 +64,7 @@ public BitStream(byte[] target)
         {
             this.target = target;
             Resizable = false;
-            BitLength = (ulong) (target.Length << 3);
+            BitLength = (ulong)(target.Length << 3);
         }
 
         /// <summary>
@@ -96,15 +96,16 @@ public BitStream(byte[] target)
         /// <summary>
         /// Current buffer size. The buffer will not be resized (if possible) until Position is equal to Capacity and an attempt to write data is made.
         /// </summary>
-        public long Capacity {
+        public long Capacity
+        {
             get => target.LongLength; // Optimized CeilingExact
             set
             {
                 if (value < Length) throw new ArgumentOutOfRangeException("New capcity too small!");
                 SetCapacity(value);
             }
         }
-        
+
         /// <summary>
         /// The current length of data considered to be "written" to the buffer.
         /// </summary>
@@ -113,7 +114,7 @@ public long Capacity {
         /// <summary>
         /// The index that will be written to when any call to write data is made to this stream.
         /// </summary>
-        public override long Position { get => (long)(BitPosition>>3); set => BitPosition = (ulong)value << 3; }
+        public override long Position { get => (long)(BitPosition >> 3); set => BitPosition = (ulong)value << 3; }
 
         /// <summary>
         /// Bit offset into the buffer that new data will be written to.
@@ -221,7 +222,7 @@ private void SetCapacity(long value)
         public override void SetLength(long value)
         {
             if (value < 0) throw new IndexOutOfRangeException("Cannot set a negative length!");
-            if (value > Capacity) Grow(value-Capacity);
+            if (value > Capacity) Grow(value - Capacity);
             BitLength = (ulong)value << 3;
         }
 
@@ -310,7 +311,7 @@ public void WriteDouble(double value)
         /// <param name="value">Value to write</param>
         public void WriteSinglePacked(float value)
         {
-            lock(holder_f)
+            lock (holder_f)
                 lock (holder_i)
                 {
                     holder_f[0] = value;
@@ -356,8 +357,8 @@ public void WriteRangedSingle(float value, float minValue, float maxValue, int b
         {
             if (bytes < 1 || bytes > 4) throw new ArgumentOutOfRangeException("Result must occupy between 1 and 4 bytes!");
             if (value < minValue || value > maxValue) throw new ArgumentOutOfRangeException("Given value does not match the given constraints!");
-            uint result = (uint)(((value + minValue)/(maxValue+minValue))*((0x100*bytes) - 1));
-            for (int i = 0; i < bytes; ++i) _WriteByte((byte)(result >> (i<<3)));
+            uint result = (uint)(((value + minValue) / (maxValue + minValue)) * ((0x100 * bytes) - 1));
+            for (int i = 0; i < bytes; ++i) _WriteByte((byte)(result >> (i << 3)));
         }
 
         /// <summary>
@@ -371,7 +372,7 @@ public void WriteRangedDouble(double value, double minValue, double maxValue, in
         {
             if (bytes < 1 || bytes > 8) throw new ArgumentOutOfRangeException("Result must occupy between 1 and 8 bytes!");
             if (value < minValue || value > maxValue) throw new ArgumentOutOfRangeException("Given value does not match the given constraints!");
-            ulong result = (ulong)(((value + minValue) / (maxValue+minValue)) * ((0x100 * bytes) - 1));
+            ulong result = (ulong)(((value + minValue) / (maxValue + minValue)) * ((0x100 * bytes) - 1));
             for (int i = 0; i < bytes; ++i) _WriteByte((byte)(result >> (i << 3)));
         }
 
@@ -383,7 +384,7 @@ public void WriteRangedDouble(double value, double minValue, double maxValue, in
         public void WriteRotation(Quaternion rotation, int bytesPerAngle)
         {
             if (bytesPerAngle < 1 || bytesPerAngle > 4) throw new ArgumentOutOfRangeException("Bytes per angle must be at least 1 byte and at most 4 bytes!");
-            if (bytesPerAngle==4) WriteVector3(rotation.eulerAngles);
+            if (bytesPerAngle == 4) WriteVector3(rotation.eulerAngles);
             else
             {
                 Vector3 rot = rotation.eulerAngles;
@@ -425,15 +426,15 @@ public double ReadDouble()
                     return holder_d[0];
                 }
         }
-        
+
         /// <summary>
         /// Read a single-precision floating point value from the stream from a varint
         /// </summary>
         /// <returns>The read value</returns>
         public float ReadSinglePacked()
         {
             uint read = ReadUInt32Packed();
-            lock(holder_f)
+            lock (holder_f)
                 lock (holder_i)
                 {
                     holder_i[0] = BinaryHelpers.SwapEndian(read);
@@ -527,7 +528,7 @@ public void WriteNibble(byte value)
                 value &= 0x0F;
                 int offset = (int)(BitPosition & 7), offset_inv = 8 - offset;
                 target[Position] = (byte)((target[Position] & (0xFF >> offset_inv)) | (byte)(value << offset));
-                if(offset > 4) target[Position + 1] = (byte)((target[Position + 1] & (0xFF << (offset & 3))) | (byte)(value >> offset_inv));
+                if (offset > 4) target[Position + 1] = (byte)((target[Position + 1] & (0xFF << (offset & 3))) | (byte)(value >> offset_inv));
                 BitPosition += 4;
             }
             UpdateLength();
@@ -546,13 +547,13 @@ public void WriteNibble(byte value)
         /// <param name="bitCount">Amount of bits to write</param>
         public void WriteBits(ulong value, int bitCount)
         {
-            if (BitPosition + (ulong)bitCount > ((ulong)target.LongLength << 3)) Grow(Div8Ceil(BitPosition+(ulong)bitCount));
+            if (BitPosition + (ulong)bitCount > ((ulong)target.LongLength << 3)) Grow(Div8Ceil(BitPosition + (ulong)bitCount));
             if (bitCount > 64) throw new ArgumentOutOfRangeException("Cannot read more than 64 bits from a 64-bit value!");
             if (bitCount < 0) throw new ArgumentOutOfRangeException("Cannot read fewer than 0 bits!");
             int count = -8;
-            while (bitCount > (count+=8)) _WriteULongByte(value >> count);
+            while (bitCount > (count += 8)) _WriteULongByte(value >> count);
             BitPosition += (ulong)count;
-            if((bitCount & 7) != 0) _WriteBits((byte)(value >> count), bitCount & 7);
+            if ((bitCount & 7) != 0) _WriteBits((byte)(value >> count), bitCount & 7);
             UpdateLength();
         }
         /// <summary>
@@ -570,7 +571,7 @@ private void _WriteBits(byte value, int bitCount)
             target[Position] = (byte)(
                     (target[Position] & (0xFF >> offset_inv)) |             // Bits prior to value (lower)
                     (target[Position] & (0xFF << (offset + bitCount))) |    // Bits after value (higher)
-                    (value<<offset)                                         // Bits to write
+                    (value << offset)                                         // Bits to write
                 );
             if (bitCount + offset > 8)
                 target[Position + 1] = (byte)(
@@ -733,15 +734,15 @@ public void WriteUInt64Packed(ulong value)
         /// Read an unsigned long (UInt64) from the stream.
         /// </summary>
         /// <returns>Value read from stream.</returns>
-        public ulong ReadUInt64() => (ulong)(
+        public ulong ReadUInt64() => (
                 _ReadByte() |
-                (_ReadByte() << 8) |
-                (_ReadByte() << 16) |
-                (_ReadByte() << 24) |
-                (_ReadByte() << 32) |
-                (_ReadByte() << 40) |
-                (_ReadByte() << 48) |
-                (_ReadByte() << 56)
+                ((ulong)_ReadByte() << 8) |
+                ((ulong)_ReadByte() << 16) |
+                ((ulong)_ReadByte() << 24) |
+                ((ulong)_ReadByte() << 32) |
+                ((ulong)_ReadByte() << 40) |
+                ((ulong)_ReadByte() << 48) |
+                ((ulong)_ReadByte() << 56)
                 );
         /// <summary>
         /// Read a signed long (Int64) from the stream.
@@ -881,19 +882,19 @@ public override void WriteByte(byte value)
         /// <param name="count">How many bytes to read. Set to value less than one to read until ReadByte returns -1</param>
         public void CopyFrom(Stream s, int count = -1)
         {
-            if(s is BitStream b) Write(b.target, 0, count < 0 ? (int)b.Length : count);
+            if (s is BitStream b) Write(b.target, 0, count < 0 ? (int)b.Length : count);
             else
             {
                 int read;
                 bool readToEnd = count < 0;
-                while((readToEnd || count-- > 0) && (read = s.ReadByte()) != -1)
+                while ((readToEnd || count-- > 0) && (read = s.ReadByte()) != -1)
                     _WriteIntByte(read);
                 UpdateLength();
             }
         }
-        
+
         // TODO: Implement CopyFrom() for BitStream with bitCount parameter
-        
+
         /// <summary>
         /// Update length of data considered to be "written" to the stream.
         /// </summary>