gg.easy.airship 0.1.2140 → 0.1.2143

package/Editor/LuauPluginUpdateCheck.cs

@@ -57,7 +57,7 @@ public static class LuauPluginUpdateCheck {
         if (lastHash != "") {
             // Check if user wants to restart
             var acceptsRestart = EditorUtility.DisplayDialog("Luau Plugin Updated",
-                "The Luau plugin has updated. Restart Unity to apply changes.", "Quit", "Cancel");
+                "The Luau plugin has updated. Restart Unity to apply changes. We're sorry for this..", "Quit", "Cancel");
             if (acceptsRestart) {
                 // Verify any unsaved changes are saved
                 var confirmedSaveState = EditorSceneManager.SaveCurrentModifiedScenesIfUserWantsTo();

package/Editor/TypescriptServices/Editor/TypescriptLogService.cs

@@ -75,8 +75,7 @@ namespace Airship.Editor {
                     }
                 }
                 
-                
-                await Task.Delay(1); // tune as needed
+                await Task.Delay(100); // tune as needed
             }
         }
 

package/Runtime/Code/Bundles/SystemRoot.cs

@@ -267,20 +267,24 @@ public class SystemRoot : Singleton<SystemRoot> {
 		this.networkCollectionIdCounter = 1;
 
 		// sort packages by load order
-		List<List<IEnumerator>> loadLists = new(3);
+		List<List<IEnumerator>> loadLists = new(2);
 		for (int i = 0; i < loadLists.Capacity; i++) {
 			loadLists.Add(new());
 		}
 
 		List<IEnumerator> GetLoadList(AirshipPackage package) {
-			return loadLists[0];
-			// if (package.id == "@Easy/CoreMaterials") {
+			// // Load core first because packages may depend them
+			// if (package.id == "@Easy/CoreMaterials" || package.id == "@Easy/Core") {
 			// 	return loadLists[0];
 			// }
-			// if (package.id == "@Easy/Core") {
-			// 	return loadLists[1];
-			// }
-			// return loadLists[2];
+
+			// All packages first
+			if (package.packageType == AirshipPackageType.Package) {
+				return loadLists[0];
+			}
+
+			// Games go last
+			return loadLists[1];
 		}
 
 		// Find packages to load
@@ -334,7 +338,10 @@ public class SystemRoot : Singleton<SystemRoot> {
 			}
 #endif
 
+			Debug.Log("Loading packages...");
 			yield return this.WaitAll(loadLists[0].ToArray());
+			Debug.Log("Loading game...");
+			yield return this.WaitAll(loadLists[1].ToArray());
 			
 			foreach (var ao in this.extraBundleLoadRequests) {
 				if (!ao.isDone) {

package/Runtime/Code/Luau/LuauCoreReflection.cs

@@ -483,6 +483,13 @@ public partial class LuauCore : MonoBehaviour
             return true;
         }
         
+        if (t == byteType) {
+            byte byteVal = (byte)value;
+            System.Int32 integer = byteVal;
+            LuauPlugin.LuauPushValueToThread(thread, (int)PODTYPE.POD_INT32, new IntPtr(value: &integer), 0); // 0, because we know how big an intPtr is
+            return true;
+        }
+        
         if (t == longType) {
             Int64 intVal = (Int64)value;
             System.Int32 integer = unchecked((int)intVal);

package/Runtime/Code/Network/ServerConsole.cs

@@ -48,7 +48,7 @@ namespace Code.RemoteConsole {
                     }
                 }
 
-                await Task.Delay(1); // tune as needed
+                await Task.Delay(100); // tune as needed
             }
         }
 

package/Runtime/Code/Network/Simulation/AirshipSimulationManager.cs

@@ -157,7 +157,11 @@ namespace Code.Network.Simulation
             G_ResimMonitor.FrameObserverBuffer = buffer;
             
             if (!isActive) return;
-            if (Physics.simulationMode != SimulationMode.Script) return;
+            if (Physics.simulationMode != SimulationMode.Script) {
+                // reset the simulation mode if it changed for some reason. This seems to happen on the server when you change prefabs
+                // while in play mode with mppm.
+                Physics.simulationMode = SimulationMode.Script;
+            }
             
             // Before running any commands, we perform any resimulation requests that were made during
             // the last tick. This ensures that resimulations don't affect command processing and

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

@@ -518,7 +518,7 @@ namespace Code.Network.StateSystem
                 else
                 {
                     // Ensure that we always tick the system even if there's no command to process.
-                    // Debug.LogWarning("No commands left. Last command processed: " + this.lastProcessedCommand);
+                    Debug.LogWarning("No commands left. Last command processed: " + this.lastProcessedCommand);
                     this.stateSystem.Tick(null, time, false);
                 }
             } while (this.serverCommandBuffer.Count >

package/Runtime/Code/Player/Character/MovementSystems/Character/CharacterMovement.cs

@@ -400,16 +400,24 @@ namespace Code.Player.Character.MovementSystems.Character {
 
             if (grounded && !currentMoveSnapshot.isGrounded) {
                 currentMoveSnapshot.jumpCount = 0;
-                currentMoveSnapshot.timeSinceBecameGrounded = 0f;
+                currentMoveSnapshot.canJump = 255;
                 OnImpactWithGround?.Invoke(currentVelocity, groundHit);
                 if (mode == NetworkedStateSystemMode.Authority && isServer) {
                     SAuthImpactEvent(currentVelocity, groundHit);
                 } else if (mode == NetworkedStateSystemMode.Authority && isClient) {
                     CAuthImpactEvent(currentVelocity, groundHit);
                 }
-            } else {
-                currentMoveSnapshot.timeSinceBecameGrounded =
-                    Math.Min(currentMoveSnapshot.timeSinceBecameGrounded + deltaTime, 100f);
+            }
+
+            // If we have transitioned to airborne
+            if (!grounded && currentMoveSnapshot.isGrounded) {
+                // Set canJump to the number of ticks of coyote time we have
+                currentMoveSnapshot.canJump = (byte) Math.Min(Math.Floor(movementSettings.jumpCoyoteTime / Time.fixedDeltaTime), 255);
+            }
+
+            if (!grounded && !currentMoveSnapshot.isGrounded) {
+                // If we've now ticked once in the air, remove a tick of canJump time.
+                currentMoveSnapshot.canJump = (byte) Math.Max(currentMoveSnapshot.canJump - 1, 0);
             }
 
             var groundSlopeDir = detectedGround
@@ -463,8 +471,10 @@ namespace Code.Player.Character.MovementSystems.Character {
                     //In the air
                     // coyote jump
                     if (currentVelocity.y < 0f &&
-                        currentMoveSnapshot.timeSinceWasGrounded <= movementSettings.jumpCoyoteTime &&
-                        currentMoveSnapshot.timeSinceJump > movementSettings.jumpCoyoteTime) {
+                        // currentMoveSnapshot.timeSinceWasGrounded <= movementSettings.jumpCoyoteTime &&
+                        // currentMoveSnapshot.timeSinceJump > movementSettings.jumpCoyoteTime
+                        currentMoveSnapshot.canJump > 0
+                        ) {
                         canJump = true;
                     }
                     //the first jump requires grounded, so if in the air bump the currentMoveState.jumpCount up
@@ -565,23 +575,6 @@ namespace Code.Player.Character.MovementSystems.Character {
                 currentMoveSnapshot.isSprinting = false;
             }
 
-            /*
-             * Update Time Since:
-             */
-
-            if (didJump) {
-                currentMoveSnapshot.timeSinceJump = 0f;
-            } else {
-                currentMoveSnapshot.timeSinceJump = Math.Min(currentMoveSnapshot.timeSinceJump + deltaTime, 100f);
-            }
-
-            if (grounded) {
-                currentMoveSnapshot.timeSinceWasGrounded = 0f;
-            } else {
-                currentMoveSnapshot.timeSinceWasGrounded =
-                    Math.Min(currentMoveSnapshot.timeSinceWasGrounded + deltaTime, 100f);
-            }
-
             #region CROUCH
 
             // Prevent falling off blocks while crouching
@@ -985,7 +978,7 @@ namespace Code.Player.Character.MovementSystems.Character {
             var didStepUp = false;
             if (movementSettings.detectStepUps && //Want to check step ups
                 (!command.crouch || !movementSettings.preventStepUpWhileCrouching) && //Not blocked by crouch
-                (movementSettings.assistedLedgeJump || currentMoveSnapshot.timeSinceBecameGrounded > .05) && //Grounded
+                (movementSettings.assistedLedgeJump || currentMoveSnapshot.canJump > 0) && //Grounded // Used to be currentMoveSnapshot.timeSinceBecameGrounded > .05
                 Mathf.Abs(newVelocity.x) + Mathf.Abs(newVelocity.z) > .05f) {
                 //Moveing
                 var (hitStepUp, onRamp, pointOnRamp, stepUpVel) = physics.StepUp(rootPosition,
@@ -1039,7 +1032,7 @@ namespace Code.Player.Character.MovementSystems.Character {
                             .1f);
                     }
 
-                    if (Physics.Raycast(projectedPosition + new Vector3(0, -.5f, 0), -normalizedVel,
+                    if (Physics.Raycast(projectedPosition + new Vector3(0, -.25f, 0), -normalizedVel,
                             out var cliffHit, distanceCheck,
                             movementSettings.groundCollisionLayerMask, QueryTriggerInteraction.Ignore)) {
 
@@ -1048,54 +1041,35 @@ namespace Code.Player.Character.MovementSystems.Character {
                         }
 
                         //Stop movement into this surface
-                        var colliderDot = 1 - Mathf.Max(0,
-                            -Vector3.Dot(-cliffHit.normal, normalizedVel));
-                        colliderDot *= .8f;
+                        // var colliderDot = 1 - Mathf.Max(0,
+                        //     -Vector3.Dot(-cliffHit.normal, newVelocity));
+                        var colliderDot = Vector3.Dot(newVelocity, -cliffHit.normal);
+                        //colliderDot *= .9f;
                         //var colliderDot = 1 - -Vector3.Dot(forwardHit.normal, forwardVector);
-                        if (Mathf.Abs(colliderDot) < .01f || normalizedVel.sqrMagnitude < 1f) {
-                            colliderDot = 0;
-                        }
-
-                        colliderDot = 0;
+                        // if (Mathf.Abs(colliderDot) < .01f || normalizedVel.sqrMagnitude < 1f) {
+                        //     colliderDot = 0;
+                        // }
                         var flatPoint = new Vector3(cliffHit.point.x, transform.position.y, cliffHit.point.z);
-                        if (Vector3.Distance(flatPoint, transform.position) < bumpSize - forwardMargin) {
+                        //If we are too close to the edge or if there is an obstruction in the way
+                        if (Vector3.Distance(flatPoint, transform.position) < bumpSize - forwardMargin
+                            || Physics.Raycast(transform.position + new Vector3(0,.25f, 0), newVelocity, distanceCheck, movementSettings.groundCollisionLayerMask)) {
                             //Snap back to the bump distance so you never inch your way to the edge 
                             //newVelocity = new Vector3(0, newVelocity.y, 0);
                             //var newPos = cliffHit.point - normalizedVel * (bumpSize-forwardMargin);
                             //transform.position = new Vector3(newPos.x, transform.position.y, newPos.z);
-
+                        
                             newVelocity = -normalizedVel;
                         } else {
-                            //limit movement dir based on how straight you are walking into the wall
+                            //limit movement dir based on how straight you are walking into the edge
                             characterMoveVelocity = Vector3.ProjectOnPlane(characterMoveVelocity, -cliffHit.normal);
                             characterMoveVelocity.y = 0;
                             characterMoveVelocity *= colliderDot;
                             normalizedMoveDir = characterMoveVelocity.normalized;
 
-                            newVelocity = Vector3.ProjectOnPlane(newVelocity, -cliffHit.normal);
-                            newVelocity *= colliderDot;
+                            newVelocity -= colliderDot * -cliffHit.normal;
+                            //newVelocity *= colliderDot;
                         }
                     }
-                    // Determine which direction we're mainly moving toward
-                    // var xFirst = Math.Abs(command.moveDir.x) > Math.Abs(command.moveDir.z);
-                    // Vector3[] vecArr = { new(command.moveDir.x, 0, 0), new(0, 0, command.moveDir.z) };
-                    // for (var i = 0; i < 2; i++) {
-                    //     // We will try x dir first if x magnitude is greater
-                    //     var index = (xFirst ? i : i + 1) % 2;
-                    //     var safeDirection = vecArr[index];
-                    //     var stepPosition = rootPosition + safeDirection.normalized * 0.2f;
-                    //     (foundGroundedDir, _, _) =
-                    //         physics.CheckIfGrounded(stepPosition, newVelocity, normalizedMoveDir);
-                    //     if (foundGroundedDir) {
-                    //         characterMoveVelocity = safeDirection;
-                    //         break;
-                    //     }
-                    // }
-
-                    // Only if we didn't find a safe direction set move to 0
-                    // if (!foundGroundedDir) {
-                    //     characterMoveVelocity = Vector3.zero;
-                    // }
                 }
             }
 
@@ -1591,7 +1565,7 @@ namespace Code.Player.Character.MovementSystems.Character {
 
             // TS listens to this to update the local camera.
             // Position will update from reconcile, but we handle look direction manually.
-            if (mode == NetworkedStateSystemMode.Authority && isServer) {
+            if (mode == NetworkedStateSystemMode.Authority && isServer && !this.manager.serverGeneratesCommands) {
                 RpcSetLookVector(lookVector);
             }
 
@@ -1654,14 +1628,6 @@ namespace Code.Player.Character.MovementSystems.Character {
             return physics.ignoredColliders.ContainsKey(collider.GetInstanceID());
         }
 
-        public float GetTimeSinceWasGrounded() {
-            return currentMoveSnapshot.timeSinceWasGrounded;
-        }
-
-        public float GetTimeSinceBecameGrounded() {
-            return currentMoveSnapshot.timeSinceBecameGrounded;
-        }
-
         public void SetVelocity(Vector3 velocity) {
             if (mode == NetworkedStateSystemMode.Observer && isServer) {
                 RpcVelocity(velocity);

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

@@ -27,9 +27,8 @@ namespace Code.Player.Character.MovementSystems.Character
         public float speedModifier = 1; // Not used yet
         public byte jumpCount;
         public CharacterState state = CharacterState.Idle;
-        public float timeSinceBecameGrounded;
-        public float timeSinceWasGrounded;
-        public float timeSinceJump;
+        // > 0 means it is possible to jump. Value is the number of ticks they have left until they can no longer jump. byte.MaxValue when grounded.
+        public byte canJump;
     
         public BinaryBlob customData;
 
@@ -50,36 +49,69 @@ namespace Code.Player.Character.MovementSystems.Character
 
             string message = "";
             
-            if (this.lastProcessedCommand != other.lastProcessedCommand)
+            var lastProcessedCommandEqual = this.lastProcessedCommand == other.lastProcessedCommand;
+            var positionEqual = this.position == other.position;
+            var velocityEqual = this.velocity == other.velocity;
+            var currentSpeedEqual = CharacterSnapshotDataSerializer.CompressToShort(this.currentSpeed) == CharacterSnapshotDataSerializer.CompressToShort(other.currentSpeed);
+            var speedModifierEqual = CharacterSnapshotDataSerializer.CompressToShort(this.speedModifier) == CharacterSnapshotDataSerializer.CompressToShort(other.speedModifier);
+            var inputDisabledEqual = inputDisabled == other.inputDisabled;
+            var isFlyingEqual = isFlying == other.isFlying;
+            var isSprintingEqual = isSprinting == other.isSprinting;
+            var jumpCountEqual = jumpCount == other.jumpCount;
+            var airborneFromImpulseEqual = airborneFromImpulse == other.airborneFromImpulse;
+            var alreadyJumpedEqual = alreadyJumped == other.alreadyJumped;
+            var isCrouchingEqual = isCrouching == other.isCrouching;
+            var prevStepUpEqual = prevStepUp == other.prevStepUp;
+            var isGroundedEqual = isGrounded == other.isGrounded;
+            var stateEqual = state == other.state;
+
+            if (!lastProcessedCommandEqual)
                 message += $"lastProcessedCommand: {this.lastProcessedCommand} != {other.lastProcessedCommand}\n";
-            if (this.position != other.position) message += $"position: {this.position} != {other.position}\n";
-            if (this.velocity != other.velocity) message += $"velocity: {this.velocity} != {other.velocity}\n";
-            if (this.currentSpeed != other.currentSpeed) message += $"currentSpeed: {this.currentSpeed} != {other.currentSpeed}\n";
-            if (this.speedModifier != other.speedModifier)
-                message += $"speedModifier: {this.speedModifier} != {other.speedModifier}";
-            if (inputDisabled != other.inputDisabled)
+            if (!positionEqual)
+                message += $"position: {this.position} != {other.position}\n";
+            if (!velocityEqual)
+                message += $"velocity: {this.velocity} != {other.velocity}\n";
+            if (!currentSpeedEqual)
+                message += $"currentSpeed: {this.currentSpeed} != {other.currentSpeed}\n";
+            if (!speedModifierEqual)
+                message += $"speedModifier: {this.speedModifier} != {other.speedModifier}\n";
+            if (!inputDisabledEqual)
                 message += $"inputDisabled: {inputDisabled} != {other.inputDisabled}\n";
-            if (isFlying != other.isFlying) message += $"isFlying: {isFlying} != {other.isFlying}\n";
-            if (isSprinting != other.isSprinting) message += $"isSprinting: {isSprinting} != {other.isSprinting}\n";
-            if (jumpCount != other.jumpCount) message += $"jumpCount: {jumpCount} != {other.jumpCount}\n";
-            if (airborneFromImpulse != other.airborneFromImpulse)
+            if (!isFlyingEqual)
+                message += $"isFlying: {isFlying} != {other.isFlying}\n";
+            if (!isSprintingEqual)
+                message += $"isSprinting: {isSprinting} != {other.isSprinting}\n";
+            if (!jumpCountEqual)
+                message += $"jumpCount: {jumpCount} != {other.jumpCount}\n";
+            if (!airborneFromImpulseEqual)
                 message += $"airborneFromImpulse: {airborneFromImpulse} != {other.airborneFromImpulse}\n";
-            if (alreadyJumped != other.alreadyJumped)
+            if (!alreadyJumpedEqual)
                 message += $"alreadyJumped: {alreadyJumped} != {other.alreadyJumped}\n";
-            if (isCrouching != other.isCrouching) message += $"prevCrouch: {isCrouching} != {other.isCrouching}\n";
-            if (prevStepUp != other.prevStepUp) message += $"prevStepUp: {prevStepUp} != {other.prevStepUp}\n";
-            if (isGrounded != other.isGrounded)
+            if (!isCrouchingEqual)
+                message += $"prevCrouch: {isCrouching} != {other.isCrouching}\n";
+            if (!prevStepUpEqual)
+                message += $"prevStepUp: {prevStepUp} != {other.prevStepUp}\n";
+            if (!isGroundedEqual)
                 message += $"prevGrounded: {isGrounded} != {other.isGrounded}\n";
-            if (state != other.state) message += $"state: {state} != {other.state}\n";
-            
-            var same =  this.lastProcessedCommand == other.lastProcessedCommand && this.position == other.position &&
-                        this.velocity == other.velocity && this.currentSpeed == other.currentSpeed && this.speedModifier == other.speedModifier &&
-                        inputDisabled == other.inputDisabled
-                        && isFlying == other.isFlying && isSprinting == other.isSprinting && jumpCount == other.jumpCount &&
-                        airborneFromImpulse == other.airborneFromImpulse &&
-                        alreadyJumped == other.alreadyJumped
-                        && isCrouching == other.isCrouching && prevStepUp == other.prevStepUp &&
-                        isGrounded == other.isGrounded && state == other.state;
+            if (!stateEqual)
+                message += $"state: {state} != {other.state}\n";
+
+            var same =
+                lastProcessedCommandEqual &&
+                positionEqual &&
+                velocityEqual &&
+                currentSpeedEqual &&
+                speedModifierEqual &&
+                inputDisabledEqual &&
+                isFlyingEqual &&
+                isSprintingEqual &&
+                jumpCountEqual &&
+                airborneFromImpulseEqual &&
+                alreadyJumpedEqual &&
+                isCrouchingEqual &&
+                prevStepUpEqual &&
+                isGroundedEqual &&
+                stateEqual;
 
             if (same)
             {
@@ -103,9 +135,7 @@ namespace Code.Player.Character.MovementSystems.Character
             this.velocity = copySnapshot.velocity;
             this.currentSpeed = copySnapshot.currentSpeed;
             this.speedModifier = copySnapshot.speedModifier;
-            this.timeSinceJump = copySnapshot.timeSinceJump;
-            this.timeSinceWasGrounded = copySnapshot.timeSinceWasGrounded;
-            this.timeSinceBecameGrounded = copySnapshot.timeSinceBecameGrounded;
+            this.canJump = copySnapshot.canJump;
             this.state = copySnapshot.state;
             this.isGrounded = copySnapshot.isGrounded;
             this.prevStepUp = copySnapshot.prevStepUp;
@@ -141,9 +171,7 @@ namespace Code.Player.Character.MovementSystems.Character
                 velocity = velocity,
                 currentSpeed = currentSpeed,
                 speedModifier = speedModifier,
-                timeSinceJump = timeSinceJump,
-                timeSinceWasGrounded = timeSinceWasGrounded,
-                timeSinceBecameGrounded = timeSinceBecameGrounded,
+                canJump = canJump,
                 state = state, 
                 isGrounded = isGrounded,
                 prevStepUp = prevStepUp,
@@ -165,6 +193,23 @@ namespace Code.Player.Character.MovementSystems.Character
     }
 
     public static class CharacterSnapshotDataSerializer {
+
+        public static ushort CompressToUshort(float value) {
+            return (ushort)Math.Clamp(value * 1000f, 0, ushort.MaxValue);
+        }
+        
+        public static short CompressToShort(float value) {
+            return (short)Math.Clamp(value * 1000f, short.MinValue, short.MaxValue);
+        }
+
+        public static float DecompressUShort(ushort value) {
+            return value / 1000f;
+        }
+
+        public static float DecompressShort(short value) {
+            return value / 1000f;
+        }
+        
         public static void WriteCharacterSnapshotData(this NetworkWriter writer, CharacterSnapshotData value) {
             byte bools = 0;
             SetBit(ref bools, 0, value.inputDisabled);
@@ -176,23 +221,26 @@ namespace Code.Player.Character.MovementSystems.Character
             SetBit(ref bools, 6, value.prevStepUp);
             SetBit(ref bools, 7, value.isGrounded);
             writer.Write(bools);
-            
-            writer.WriteInt(value.customData.dataSize);
-            writer.WriteBytes(value.customData.data, 0, value.customData.data.Length);
+
+            if (value.customData != null) {
+                writer.WriteInt(value.customData.dataSize);
+                writer.WriteBytes(value.customData.data, 0, value.customData.data.Length);
+            }
+            else {
+                writer.WriteInt(0);
+            }
             
             writer.Write(value.time);
             writer.Write(value.lastProcessedCommand);
             writer.Write(value.position);
             writer.Write(value.velocity);
-            writer.Write((short)(value.lookVector.x * 1000f));
-            writer.Write((short)(value.lookVector.y * 1000f));
-            writer.Write((short)(value.lookVector.z * 1000f));
+            writer.Write(CompressToShort(value.lookVector.x));
+            writer.Write(CompressToShort(value.lookVector.y));
+            writer.Write(CompressToShort(value.lookVector.z));
             writer.Write(value.currentSpeed);
             // This makes our max speed modifier 65.535 with a 0.001 precision.
-            writer.Write((ushort) Math.Clamp(value.speedModifier * 1000f, 0, ushort.MaxValue));
-            writer.Write((byte) Math.Min(Math.Floor(value.timeSinceJump / Time.fixedDeltaTime), 255));
-            writer.Write((byte) Math.Min(Math.Floor(value.timeSinceWasGrounded / Time.fixedDeltaTime), 255));
-            writer.Write((byte) Math.Min(Math.Floor(value.timeSinceBecameGrounded / Time.fixedDeltaTime), 255));
+            writer.Write(CompressToUshort(value.speedModifier));
+            writer.Write(value.canJump);
             writer.Write((byte) value.state);
             writer.Write(value.jumpCount);
         }
@@ -200,8 +248,11 @@ namespace Code.Player.Character.MovementSystems.Character
         public static CharacterSnapshotData ReadCharacterSnapshotData(this NetworkReader reader) {
             var bools = reader.Read<byte>();
             var customDataSize = reader.ReadInt();
-            var customDataArray = reader.ReadBytes(customDataSize);
-            var customData = new BinaryBlob(customDataArray);
+            BinaryBlob customData = default;
+            if (customDataSize != 0) {
+                var customDataArray = reader.ReadBytes(customDataSize);
+                customData = new BinaryBlob(customDataArray);
+            }
             return new CharacterSnapshotData() {
                 inputDisabled = GetBit(bools, 0),
                 isFlying = GetBit(bools, 1),
@@ -211,17 +262,17 @@ namespace Code.Player.Character.MovementSystems.Character
                 isCrouching = GetBit(bools, 5),
                 prevStepUp = GetBit(bools, 6),
                 isGrounded = GetBit(bools, 7),
-                
                 time = reader.Read<double>(),
                 lastProcessedCommand = reader.Read<int>(),
                 position = reader.Read<Vector3>(),
                 velocity = reader.Read<Vector3>(),
-                lookVector = new Vector3(reader.Read<short>() / 1000f, reader.Read<short>() / 1000f, reader.Read<short>() / 1000f),
+                lookVector = new Vector3(
+                    DecompressShort(reader.Read<short>()), 
+                    DecompressShort(reader.Read<short>()), 
+                    DecompressShort(reader.Read<short>())),
                 currentSpeed = reader.Read<float>(),
-                speedModifier = reader.Read<ushort>() / 1000f,
-                timeSinceJump = reader.Read<byte>() * Time.fixedDeltaTime,
-                timeSinceWasGrounded = reader.Read<byte>() * Time.fixedDeltaTime,
-                timeSinceBecameGrounded = reader.Read<byte>() * Time.fixedDeltaTime,
+                speedModifier = DecompressUShort(reader.Read<ushort>()),
+                canJump = reader.Read<byte>(),
                 state = (CharacterState) reader.Read<byte>(),
                 jumpCount = reader.Read<byte>(),
                 customData = customData,

package/Runtime/DevConsole/Runtime/DevConsoleMono.cs

@@ -675,8 +675,6 @@ namespace Airship.DevConsole
             _inputField.textComponent.alignment = TextAnchor.MiddleLeft;
            
             if (EventSystem.current != null) {
-                // if (_inputField.isFocused)
-                print("setting to null");
                 EventSystem.current.SetSelectedGameObject(null);
             }
 
@@ -1385,7 +1383,6 @@ namespace Airship.DevConsole
 
             // Force the input field to be focused by the event system
             if (_focusInputField && !Application.isMobilePlatform) {
-                Debug.Log("Selecting input field.");
                 EventSystem.current.SetSelectedGameObject(_inputField.gameObject);
                 _focusInputField = false;
             }

package/ScriptableBuildPipeline/Editor/Tasks/CalculateAssetDependencyData.cs

@@ -155,7 +155,9 @@ namespace UnityEditor.Build.Pipeline.Tasks
             {
                 foreach (AssetOutput o in output.AssetResults)
                 {
-                    m_DependencyData.AssetInfo.Add(o.asset, o.assetInfo);
+                    if (!m_DependencyData.AssetInfo.TryAdd(o.asset, o.assetInfo)) {
+                        Debug.LogWarning("m_DependencyData already contained asset: " + AssetDatabase.GUIDToAssetPath(o.asset));
+                    }
                     foreach (var objectDependencyInfo in o.objectDependencyInfo)
                         m_ObjectDependencyData.ObjectDependencyMap[objectDependencyInfo.Object] = objectDependencyInfo.Dependencies;
                 }
@@ -167,7 +169,7 @@ namespace UnityEditor.Build.Pipeline.Tasks
                         ExpandReferences(assetOutput, m_ObjectDependencyData.ObjectDependencyMap);
 #endif
 
-                    m_DependencyData.AssetUsage.Add(assetOutput.asset, assetOutput.usageTags);
+                    m_DependencyData.AssetUsage.TryAdd(assetOutput.asset, assetOutput.usageTags);
 
                     Dictionary<ObjectIdentifier, System.Type[]> objectTypes = new Dictionary<ObjectIdentifier, Type[]>();
                     foreach (var objectType in assetOutput.objectTypes)
@@ -183,21 +185,21 @@ namespace UnityEditor.Build.Pipeline.Tasks
                             ReferencedObjects = assetOutput.assetInfo.referencedObjects,
                             ObjectTypes = objectTypes
                         };
-                        m_Results.AssetResults.Add(assetOutput.asset, resultData);
+                        m_Results.AssetResults.TryAdd(assetOutput.asset, resultData);
                     }
 
                     if (assetOutput.spriteData != null)
                     {
                         if (m_SpriteData == null)
                             m_SpriteData = new BuildSpriteData();
-                        m_SpriteData.ImporterData.Add(assetOutput.asset, assetOutput.spriteData);
+                        m_SpriteData.ImporterData.TryAdd(assetOutput.asset, assetOutput.spriteData);
                     }
 
                     if (!m_Parameters.DisableVisibleSubAssetRepresentations && assetOutput.extendedData != null)
                     {
                         if (m_ExtendedAssetData == null)
                             m_ExtendedAssetData = new BuildExtendedAssetData();
-                        m_ExtendedAssetData.ExtendedData.Add(assetOutput.asset, assetOutput.extendedData);
+                        m_ExtendedAssetData.ExtendedData.TryAdd(assetOutput.asset, assetOutput.extendedData);
                     }
 
                     if (assetOutput.objectTypes != null)

package/ThirdParty/Mirror/Core/NetworkClient.cs

@@ -1045,7 +1045,9 @@ namespace Mirror
         // the players object for example.
         public static bool Ready()
         {
+            #if AIRSHIP_PLAYER
             Debug.Log($"NetworkClient.Ready() called with active scene: " + SceneManager.GetActiveScene().name);
+            #endif
             if (ready)
             {
                 Debug.LogError("NetworkClient is already ready. It shouldn't be called twice.");

package/package.json

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