Merge master

Author: TwoTenPvP

MLAPI/MonoBehaviours/Core/NetworkedBehaviour.cs

@@ -258,13 +258,21 @@ internal void NetworkedVarInit()
                 channelMappedVarIndexes[firstLevelIndex[channel]].Add(i);
             }
         }
-
+        
+        private readonly List<int> networkedVarIndexesToReset = new List<int>();
+        private readonly HashSet<int> networkedVarIndexesToResetSet = new HashSet<int>();
         internal void NetworkedVarUpdate()
         {
             if (!networkedVarInit)
                 NetworkedVarInit();
             //TODO: Do this efficiently.
 
+            if (!CouldHaveDirtyVars()) 
+                return;
+
+            networkedVarIndexesToReset.Clear();
+            networkedVarIndexesToResetSet.Clear();
+            
             for (int i = 0; i < NetworkingManager.singleton.ConnectedClientsList.Count; i++)
             {
                 //This iterates over every "channel group".
@@ -278,6 +286,7 @@ internal void NetworkedVarUpdate()
                             writer.WriteUInt16Packed(networkedObject.GetOrderIndex(this));
 
                             uint clientId = NetworkingManager.singleton.ConnectedClientsList[i].ClientId;
+                            bool writtenAny = false;
                             for (int k = 0; k < networkedVarFields.Count; k++)
                             {
                                 if (!channelMappedVarIndexes[j].Contains(k))
@@ -291,19 +300,42 @@ internal void NetworkedVarUpdate()
                                 writer.WriteBool(isDirty);
                                 if (isDirty && (!isServer || networkedVarFields[k].CanClientRead(clientId)))
                                 {
+                                    writtenAny = true;
                                     networkedVarFields[k].WriteDelta(stream);
-                                    networkedVarFields[k].ResetDirty();
+                                    if (!networkedVarIndexesToResetSet.Contains(k))
+                                    {
+                                        networkedVarIndexesToResetSet.Add(k);
+                                        networkedVarIndexesToReset.Add(k);
+                                    }
                                 }
                             }
-
-                            if (isServer)
-                                InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA, channelsForVarGroups[j], stream, new InternalSecuritySendOptions(false, false));
-                            else
-                                InternalMessageHandler.Send(NetworkingManager.singleton.ServerClientId, MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA, channelsForVarGroups[j], stream, new InternalSecuritySendOptions(false, false));
+                            
+                            if (writtenAny)
+                            {
+                                if (isServer)
+                                    InternalMessageHandler.Send(clientId, MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA, channelsForVarGroups[j], stream, new InternalSecuritySendOptions(false, false));
+                                else
+                                    InternalMessageHandler.Send(NetworkingManager.singleton.ServerClientId, MLAPIConstants.MLAPI_NETWORKED_VAR_DELTA, channelsForVarGroups[j], stream, new InternalSecuritySendOptions(false, false));   
+                            }
                         }
                     }
                 }
             }
+
+            for (int i = 0; i < networkedVarIndexesToReset.Count; i++)
+            {
+                networkedVarFields[networkedVarIndexesToReset[i]].ResetDirty();
+            }
+        }
+
+        private bool CouldHaveDirtyVars()
+        {
+            for (int i = 0; i < networkedVarFields.Count; i++)
+            {
+                if (networkedVarFields[i].IsDirty()) 
+                    return true;
+            }
+            return false;
         }
 
         internal void HandleNetworkedVarDeltas(Stream stream, uint clientId)

MLAPI/NetworkingManagerComponents/Binary/BitStream.cs

@@ -42,18 +42,6 @@ public BitStream(int capacity) : this(capacity, initialGrowthFactor) { }
         /// </summary>
         public BitStream() : this(initialCapacity, initialGrowthFactor) { }
 
-        /// <summary>
-        /// A stream that supports writing data smaller than a single byte. This stream also has a built-in compression algorithm that can (optionally) be used to write compressed data.
-        /// </summary>
-        /// <param name="target">The buffer containing initial data</param>
-        /// <param name="offset">The offset where the data begins</param>
-        /// <param name="count">The amount of bytes to copy from the initial data buffer</param>
-        public BitStream(byte[] target, int offset, int count) : this(count)
-        {
-            Buffer.BlockCopy(target, offset, this.target, 0, count);
-            Resizable = false;
-        }
-
         /// <summary>
         /// A stream that supports writing data smaller than a single byte. This stream also has a built-in compression algorithm that can (optionally) be used to write compressed data.
         /// NOTE: when using a pre-allocated buffer, the stream will not grow!
@@ -78,9 +66,14 @@ public BitStream(byte[] target)
         public float GrowthFactor { set { _growthFactor = value <= 1 ? 1.5f : value; } get { return _growthFactor; } }
 
         /// <summary>
-        /// Whether or not data can be read from the stream.
+        /// Whether or not stream supports reading. (Always true)
+        /// </summary>
+        public override bool CanRead => true;
+
+        /// <summary>
+        /// Wheter or not or there is any data to be read from the stream.
         /// </summary>
-        public override bool CanRead => Position < target.LongLength;
+        public bool HasDataToRead => Position < Length;
 
         /// <summary>
         /// Whether or not seeking is supported by this stream. (Always true)
@@ -167,14 +160,14 @@ private byte ReadByteMisaligned()
         /// Read a byte from the buffer. This takes into account possible byte misalignment.
         /// </summary>
         /// <returns>A byte from the buffer or, if a byte can't be read, -1.</returns>
-        public override int ReadByte() => CanRead ? BitAligned ? ReadByteAligned() : ReadByteMisaligned() : -1;
+        public override int ReadByte() => HasDataToRead ? BitAligned ? ReadByteAligned() : ReadByteMisaligned() : -1;
 
         /// <summary>
         /// Peeks a byte without advancing the position
         /// </summary>
         /// <returns>The peeked byte</returns>
         public int PeekByte() =>
-            CanRead ?
+            HasDataToRead ?
                 BitAligned ?
                     target[Position] :
                     (byte)((target[(int)Position] >> (int)(BitPosition & 7)) | (target[(int)(BitPosition + 8) >> 3] << (8 - (int)(BitPosition & 7)))) :