gg.easy.airship 0.1.2150 → 0.1.2151

package/Runtime/Code/Network/StateSystem/AirshipNetworkedStateManager.cs

@@ -71,6 +71,7 @@ namespace Code.Network.StateSystem
 
         // How many commands we should generally have in the command buffer
         private int serverCommandBufferTargetSize = 0;
+        private int serverCommandCatchUpRequired = 0;
 
         // Non-auth server command tracking
         // Note: we also re-use some of the above command buffer fields
@@ -331,6 +332,20 @@ namespace Code.Network.StateSystem
             {
                 this.Interpolate();
             }
+
+            // We check this in Update so that we have finished processing all required fixedUpdates before checking
+            // if we are behind. Next time fixed update runs, we will process the additional amount we need to catch up.
+            if (isServer && serverAuth) {
+                if (serverCommandBuffer.Count > serverCommandBufferTargetSize) {
+                    serverCommandCatchUpRequired = serverCommandBuffer.Count - serverCommandBufferTargetSize;
+                    print($"Command catchup required for {this.name}: {serverCommandCatchUpRequired}");
+                }
+                else {
+                    serverCommandCatchUpRequired = 0;
+                }
+            }
+            
+            // todo: we probably need to do the same as above for client auth snapshots
         }
 
         #endregion
@@ -551,25 +566,21 @@ namespace Code.Network.StateSystem
             }
 
             // Delay processing until we have at least one send interval worth of commands to process.
-            if (this.serverCommandBuffer.Count == 0 ||
-                this.serverCommandBuffer.Keys[^1] - (this.serverLastProcessedCommandNumber + 1) <
-                (int)Math.Ceiling(NetworkClient.sendInterval / Time.fixedUnscaledDeltaTime)) {
-                // Debug.Log($"Waiting for additional commands for {this.name}. There are {this.serverCommandBuffer.Count} commands in the buffer.");
+            if (this.serverCommandBuffer.Count == 0 || this.serverCommandBuffer.Count < Math.Ceiling(NetworkClient.sendInterval / Time.fixedUnscaledDeltaTime)) {
+                Debug.Log($"Waiting for additional commands for {this.name}. There are {this.serverCommandBuffer.Count} commands in the buffer.");
                 this.stateSystem.Tick(null, tick, time, false);
                 return;
             }
             
             var commandsProcessed = 0;
-            do
-            {
+            do {
                 commandsProcessed++;
 
                 // Attempt to get a new command out of the buffer.
                 var commandEntry = this.serverCommandBuffer.Count > 0 ? this.serverCommandBuffer.Values[0] : null;
 
                 // If we have a new command to process
-                if (commandEntry != null)
-                {
+                if (commandEntry != null) {
                     // Get the command to process
                     var command = this.serverCommandBuffer.Values[0];
                     // Get the expected next command number
@@ -582,10 +593,10 @@ namespace Code.Network.StateSystem
                     if (this.lastProcessedCommand != null && command.commandNumber != expectedNextCommandNumber &&
                         this.serverPredictedCommandCount < Math.Ceiling(this.maxServerCommandPrediction *
                                                                         (NetworkServer.sendInterval /
-                                                                         Time.fixedUnscaledDeltaTime)))
-                    {
+                                                                         Time.fixedUnscaledDeltaTime))) {
                         Debug.LogWarning("Missing command " + expectedNextCommandNumber +
-                                         " in the command buffer for " + this.name + ". Next command was: " + command.commandNumber +
+                                         " in the command buffer for " + this.name + ". Next command was: " +
+                                         command.commandNumber +
                                          ". Predicted " +
                                          (this.serverPredictedCommandCount + 1) + " command(s) so far.");
                         this.serverLastProcessedCommandNumber = expectedNextCommandNumber;
@@ -595,8 +606,7 @@ namespace Code.Network.StateSystem
                     }
                     // We have a valid command that is in sequence, or we reached our max fill. Remove the next
                     // valid command from the buffer and process it.
-                    else
-                    {
+                    else {
                         // Debug.Log("Ticking next command in sequence: " + command.commandNumber);
                         this.serverPredictedCommandCount = 0;
                         this.serverCommandBuffer.RemoveAt(0);
@@ -608,20 +618,23 @@ namespace Code.Network.StateSystem
                     command.tick = tick; // Correct tick to local timeline for ticking on the server.
                     this.stateSystem.Tick(command, tick, time, false);
                 }
-                else
-                {
+                else {
                     // Ensure that we always tick the system even if there's no command to process.
-                    Debug.LogWarning($"No commands left for {this.name}. Last command processed: " + this.lastProcessedCommand);
+                    Debug.LogWarning($"No commands left for {this.name}. Last command processed: " +
+                                     this.lastProcessedCommand);
                     this.stateSystem.Tick(null, tick, time, false);
                     // we processed a command that never reached the server, advance so the associated
                     // command's tick result will be used to match up with state. The command that should have been used
                     // here will be ignored when it arrives (if it ever does)
-                    this.serverLastProcessedCommandNumber += 1; 
+                    this.serverLastProcessedCommandNumber += 1;
                 }
-            } while (this.serverCommandBuffer.Count >
-                     serverCommandBufferTargetSize &&
-                     commandsProcessed < 1 + this.maxServerCommandCatchup);
-            // ^ we process up to maxServerCommandCatchup commands per tick if our buffer has more than serverCommandBufferTargetSize worth of additional commands.
+
+                if (commandsProcessed > 1) {
+                    serverCommandCatchUpRequired--;
+                }
+                
+            } while (commandsProcessed < 1 + this.maxServerCommandCatchup && serverCommandCatchUpRequired > 0);
+            // We add 1 to maxServerCommandCatchup because we always want to process at least 1 command per fixed update.
 
             if (commandsProcessed > 1)
             {

package/Runtime/Code/Network/StateSystem/Structures/StateSnapshot.cs

@@ -14,7 +14,7 @@ namespace Code.Network.StateSystem.Structures
         /**
          * The unscaled time the snapshot was created. This time is local to the client/server that created it. In server
          * authoritative mode, this time is what is used to render observed characters. This should _not_ be converted
-         * to ticks! Ticks use scaled time and will not always map 1 to 1 with a real time value.
+         * to ticks! Ticks use scaled time and will not always map 1 to 1 with a unscaled time value.
          */
         public double time;
         public uint tick;

package/Runtime/Code/Player/Character/MovementSystems/Character/Structures/CharacterSnapshotData.cs

@@ -60,8 +60,8 @@ namespace Code.Player.Character.MovementSystems.Character
             var lastProcessedCommandEqual = this.lastProcessedCommand == other.lastProcessedCommand;
             var positionEqual = (this.position - other.position).sqrMagnitude < vectorTolerance;
             var velocityEqual =  (this.velocity - other.velocity).sqrMagnitude < vectorTolerance;
-            var currentSpeedEqual = NetworkSerializationUtil.CompressToShort(this.currentSpeed) == NetworkSerializationUtil.CompressToShort(other.currentSpeed);
-            var speedModifierEqual = NetworkSerializationUtil.CompressToShort(this.speedModifier) == NetworkSerializationUtil.CompressToShort(other.speedModifier);
+            var currentSpeedEqual = Math.Round(this.currentSpeed, 2) == Math.Round(other.currentSpeed, 2);
+            var speedModifierEqual = NetworkSerializationUtil.CompressToUshort(this.speedModifier) == NetworkSerializationUtil.CompressToUshort(other.speedModifier);
             var inputDisabledEqual = inputDisabled == other.inputDisabled;
             var isFlyingEqual = isFlying == other.isFlying;
             var isSprintingEqual = isSprinting == other.isSprinting;
@@ -252,7 +252,7 @@ namespace Code.Player.Character.MovementSystems.Character
             if (canJumpChanged) BitUtil.SetBit(ref changedMask, 8, true);
 
             // Write only changed fields
-            var writer = new NetworkWriter();
+            var writer = NetworkWriterPool.Get();
             writer.Write(NetworkSerializationUtil.CompressToUshort(other.time - time));
             writer.Write((ushort)(other.tick - tick)); // We should send diffs far before 65,535 ticks have passed. 255 is a little too low if messing with time scale (ticks will skip in slow timescales)
             writer.Write((ushort)(other.lastProcessedCommand - lastProcessedCommand)); // same with commands (~1 processed per tick)
@@ -279,10 +279,13 @@ namespace Code.Player.Character.MovementSystems.Character
                 writer.WriteBytes(customDataDiff, 0, customDataDiff.Length);
             }
 
+            var dataArray = writer.ToArray();
+            NetworkWriterPool.Return(writer);
+            
             return new CharacterStateDiff {
                 baseTick = tick, // The base is the instance CreateDiff is being called on, so use our instance time value as the base time.
                 crc32 = other.ComputeCrc32(),
-                data = writer.ToArray()
+                data = dataArray
             };
         }
 
@@ -305,7 +308,7 @@ namespace Code.Player.Character.MovementSystems.Character
                 return null;
             }
 
-            var reader = new NetworkReader(stateDiff.data);
+            var reader = NetworkReaderPool.Get(stateDiff.data);
             var snapshot = (CharacterSnapshotData) this.Clone();
 
             snapshot.time = time + NetworkSerializationUtil.DecompressUShort(reader.Read<ushort>());
@@ -346,6 +349,8 @@ namespace Code.Player.Character.MovementSystems.Character
             else {
                 snapshot.customData = null;
             }
+            
+            NetworkReaderPool.Return(reader);
 
             var crc32 = snapshot.ComputeCrc32();
             if (crc32 != diff.crc32) {
@@ -365,29 +370,28 @@ namespace Code.Player.Character.MovementSystems.Character
             
             // We serialize to a byte array for calculating the CRC32. We use slightly more lenient compression
             // on things like the vectors so that floating point errors don't cause the crc checks to fail.
-            var writer = new NetworkWriter();
+            var writer = NetworkWriterPool.Get();
             byte bools = 0;
             CharacterSnapshotDataSerializer.EncodeBools(ref bools, this);
             writer.Write(bools);
-            if (this.customData != null) {
-                writer.WriteInt(this.customData.dataSize);
-                writer.WriteBytes(this.customData.data, 0, this.customData.data.Length);
-            }
-            else {
-                writer.WriteInt(0);
-            }
             writer.Write(this.tick);
             writer.Write(this.lastProcessedCommand);
-            writer.Write(NetworkSerializationUtil.CompressToShort(this.position.x));
-            writer.Write(NetworkSerializationUtil.CompressToShort(this.position.y));
-            writer.Write(NetworkSerializationUtil.CompressToShort(this.position.z));
-            writer.Write(NetworkSerializationUtil.CompressToShort(this.velocity.x));
-            writer.Write(NetworkSerializationUtil.CompressToShort(this.velocity.y));
-            writer.Write(NetworkSerializationUtil.CompressToShort(this.velocity.z));
+            
+            // Floating point issue make it difficult to use these values directly. We normalize them
+            // and compress to short. We need to normalize since these values can be larger than a short.
+            var normalPos = this.position.normalized;
+            writer.Write(NetworkSerializationUtil.CompressToShort(normalPos.x));
+            writer.Write(NetworkSerializationUtil.CompressToShort(normalPos.y));
+            writer.Write(NetworkSerializationUtil.CompressToShort(normalPos.z));
+            var normalVel = this.velocity.normalized;
+            writer.Write(NetworkSerializationUtil.CompressToShort(normalVel.x));
+            writer.Write(NetworkSerializationUtil.CompressToShort(normalVel.y));
+            writer.Write(NetworkSerializationUtil.CompressToShort(normalVel.z));
+            
             writer.Write(NetworkSerializationUtil.CompressToShort(this.lookVector.x));
             writer.Write(NetworkSerializationUtil.CompressToShort(this.lookVector.y));
             writer.Write(NetworkSerializationUtil.CompressToShort(this.lookVector.z));
-            writer.Write(this.currentSpeed);
+            writer.Write(Math.Round(this.currentSpeed, 2));
             // This makes our max speed modifier 65.535 with a 0.001 precision.
             writer.Write(NetworkSerializationUtil.CompressToUshort(this.speedModifier));
             writer.Write(this.canJump);
@@ -396,6 +400,8 @@ namespace Code.Player.Character.MovementSystems.Character
             if (this.customData != null) writer.Write(this.customData.data);
             var bytes = writer.ToArray();
             
+            NetworkWriterPool.Return(writer);
+            
             _crc32 = Crc32Algorithm.Compute(bytes);
             return _crc32;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gg.easy.airship",
-  "version": "0.1.2150",
+  "version": "0.1.2151",
   "displayName": "Airship",
   "unity": "2021.3",
   "unityRelease": "12f1",