com.unity.netcode.gameobjects@1.4.0

The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).

Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).

## [1.4.0] - 2023-04-10

### Added

- Added a way to access the GlobalObjectIdHash via PrefabIdHash for use in the Connection Approval Callback. (#2437)
- Added `OnServerStarted` and `OnServerStopped` events that will trigger only on the server (or host player) to notify that the server just started or is no longer active (#2420)
- Added `OnClientStarted` and `OnClientStopped` events that will trigger only on the client (or host player) to notify that the client just started or is no longer active (#2420)
- Added `NetworkTransform.UseHalfFloatPrecision` property that, when enabled, will use half float values for position, rotation, and scale. This yields a 50% bandwidth savings a the cost of precision. (#2388)
- Added `NetworkTransform.UseQuaternionSynchronization` property that, when enabled, will synchronize the entire quaternion. (#2388)
- Added `NetworkTransform.UseQuaternionCompression` property that, when enabled, will use a smallest three implementation reducing a full quaternion synchronization update to the size of an unsigned integer. (#2388)
- Added `NetworkTransform.SlerpPosition` property that, when enabled along with interpolation being enabled, will interpolate using `Vector3.Slerp`. (#2388)
- Added `BufferedLinearInterpolatorVector3` that replaces the float version, is now used by `NetworkTransform`, and provides the ability to enable or disable `Slerp`. (#2388)
- Added `HalfVector3` used for scale when half float precision is enabled. (#2388)
- Added `HalfVector4` used for rotation when half float precision and quaternion synchronization is enabled. (#2388)
- Added `HalfVector3DeltaPosition` used for position when half float precision is enabled. This handles loss in position precision by updating only the delta position as opposed to the full position. (#2388)
- Added `NetworkTransform.GetSpaceRelativePosition` and `NetworkTransform.GetSpaceRelativeRotation` helper methods to return the proper values depending upon whether local or world space. (#2388)
- Added `NetworkTransform.OnAuthorityPushTransformState` virtual method that is invoked just prior to sending the `NetworkTransformState` to non-authoritative instances. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388)
- Added `NetworkTransform.OnNetworkTransformStateUpdated` virtual method that is invoked just after the authoritative `NetworkTransformState` is applied. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388)
- Added `NetworkTransform.OnInitialize`virtual method that is invoked after the `NetworkTransform` has been initialized or re-initialized when ownership changes. This provides for a way to make adjustments when `NetworkTransform` is initialized (i.e. resetting client prediction etc) (#2388)
- Added `NetworkObject.SynchronizeTransform` property (default is true) that provides users with another way to help with bandwidth optimizations where, when set to false, the `NetworkObject`'s associated transform will not be included when spawning and/or synchronizing late joining players. (#2388)
- Added `NetworkSceneManager.ActiveSceneSynchronizationEnabled` property, disabled by default, that enables client synchronization of server-side active scene changes. (#2383)
- Added `NetworkObject.ActiveSceneSynchronization`, disabled by default, that will automatically migrate a `NetworkObject` to a newly assigned active scene. (#2383)
- Added `NetworkObject.SceneMigrationSynchronization`, enabled by default, that will synchronize client(s) when a `NetworkObject` is migrated into a new scene on the server side via `SceneManager.MoveGameObjectToScene`. (#2383)

### Changed

- Made sure the `CheckObjectVisibility` delegate is checked and applied, upon `NetworkShow` attempt. Found while supporting (#2454), although this is not a fix for this (already fixed) issue. (#2463)
- Changed `NetworkTransform` authority handles delta checks on each new network tick and no longer consumes processing cycles checking for deltas for all frames in-between ticks. (#2388)
- Changed the `NetworkTransformState` structure is now public and now has public methods that provide access to key properties of the `NetworkTransformState` structure. (#2388)
- Changed `NetworkTransform` interpolation adjusts its interpolation "ticks ago" to be 2 ticks latent if it is owner authoritative and the instance is not the server or 1 tick latent if the instance is the server and/or is server authoritative. (#2388)
- Updated `NetworkSceneManager` to migrate dynamically spawned `NetworkObject`s with `DestroyWithScene` set to false into the active scene if their current scene is unloaded. (#2383)
- Updated the server to synchronize its local `NetworkSceneManager.ClientSynchronizationMode` during the initial client synchronization. (#2383)

### Fixed

- Fixed issue where during client synchronization the synchronizing client could receive a ObjectSceneChanged message before the client-side NetworkObject instance had been instantiated and spawned. (#2502)
- Fixed issue where `NetworkAnimator` was building client RPC parameters to exclude the host from sending itself messages but was not including it in the ClientRpc parameters. (#2492)
- Fixed issue where `NetworkAnimator` was not properly detecting and synchronizing cross fade initiated transitions. (#2481)
- Fixed issue where `NetworkAnimator` was not properly synchronizing animation state updates. (#2481)
- Fixed float NetworkVariables not being rendered properly in the inspector of NetworkObjects. (#2441)
- Fixed an issue where Named Message Handlers could remove themselves causing an exception when the metrics tried to access the name of the message.(#2426)
- Fixed registry of public `NetworkVariable`s in derived `NetworkBehaviour`s (#2423)
- Fixed issue where runtime association of `Animator` properties to `AnimationCurve`s would cause `NetworkAnimator` to attempt to update those changes. (#2416)
- Fixed issue where `NetworkAnimator` would not check if its associated `Animator` was valid during serialization and would spam exceptions in the editor console. (#2416)
- Fixed issue with a child's rotation rolling over when interpolation is enabled on a `NetworkTransform`. Now using half precision or full quaternion synchronization will always update all axis. (#2388)
- Fixed issue where `NetworkTransform` was not setting the teleport flag when the `NetworkTransform.InLocalSpace` value changed. This issue only impacted `NetworkTransform` when interpolation was enabled. (#2388)
- Fixed issue when the `NetworkSceneManager.ClientSynchronizationMode` is `LoadSceneMode.Additive` and the server changes the currently active scene prior to a client connecting then upon a client connecting and being synchronized the NetworkSceneManager would clear its internal ScenePlacedObjects list that could already be populated. (#2383)
- Fixed issue where a client would load duplicate scenes of already preloaded scenes during the initial client synchronization and `NetworkSceneManager.ClientSynchronizationMode` was set to `LoadSceneMode.Additive`. (#2383)

CHANGELOG.md

@@ -6,6 +6,87 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 Additional documentation and release notes are available at [Multiplayer Documentation](https://docs-multiplayer.unity3d.com).
 
+## [1.4.0] - 2023-04-10
+
+### Added
+
+- Added a way to access the GlobalObjectIdHash via PrefabIdHash for use in the Connection Approval Callback. (#2437)
+- Added `OnServerStarted` and `OnServerStopped` events that will trigger only on the server (or host player) to notify that the server just started or is no longer active (#2420)
+- Added `OnClientStarted` and `OnClientStopped` events that will trigger only on the client (or host player) to notify that the client just started or is no longer active (#2420)
+- Added `NetworkTransform.UseHalfFloatPrecision` property that, when enabled, will use half float values for position, rotation, and scale. This yields a 50% bandwidth savings a the cost of precision. (#2388)
+- Added `NetworkTransform.UseQuaternionSynchronization` property that, when enabled, will synchronize the entire quaternion. (#2388)
+- Added `NetworkTransform.UseQuaternionCompression` property that, when enabled, will use a smallest three implementation reducing a full quaternion synchronization update to the size of an unsigned integer. (#2388)
+- Added `NetworkTransform.SlerpPosition` property that, when enabled along with interpolation being enabled, will interpolate using `Vector3.Slerp`. (#2388)
+- Added `BufferedLinearInterpolatorVector3` that replaces the float version, is now used by `NetworkTransform`, and provides the ability to enable or disable `Slerp`. (#2388)
+- Added `HalfVector3` used for scale when half float precision is enabled. (#2388)
+- Added `HalfVector4` used for rotation when half float precision and quaternion synchronization is enabled. (#2388)
+- Added `HalfVector3DeltaPosition` used for position when half float precision is enabled. This handles loss in position precision by updating only the delta position as opposed to the full position. (#2388)
+- Added `NetworkTransform.GetSpaceRelativePosition` and `NetworkTransform.GetSpaceRelativeRotation` helper methods to return the proper values depending upon whether local or world space. (#2388)
+- Added `NetworkTransform.OnAuthorityPushTransformState` virtual method that is invoked just prior to sending the `NetworkTransformState` to non-authoritative instances. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388)
+- Added `NetworkTransform.OnNetworkTransformStateUpdated` virtual method that is invoked just after the authoritative `NetworkTransformState` is applied. This provides users with the ability to obtain more precise delta values for prediction related calculations. (#2388)
+- Added `NetworkTransform.OnInitialize`virtual method that is invoked after the `NetworkTransform` has been initialized or re-initialized when ownership changes. This provides for a way to make adjustments when `NetworkTransform` is initialized (i.e. resetting client prediction etc) (#2388)
+- Added `NetworkObject.SynchronizeTransform` property (default is true) that provides users with another way to help with bandwidth optimizations where, when set to false, the `NetworkObject`'s associated transform will not be included when spawning and/or synchronizing late joining players. (#2388)
+- Added `NetworkSceneManager.ActiveSceneSynchronizationEnabled` property, disabled by default, that enables client synchronization of server-side active scene changes. (#2383)
+- Added `NetworkObject.ActiveSceneSynchronization`, disabled by default, that will automatically migrate a `NetworkObject` to a newly assigned active scene. (#2383)
+- Added `NetworkObject.SceneMigrationSynchronization`, enabled by default, that will synchronize client(s) when a `NetworkObject` is migrated into a new scene on the server side via `SceneManager.MoveGameObjectToScene`. (#2383)
+
+### Changed
+
+- Made sure the `CheckObjectVisibility` delegate is checked and applied, upon `NetworkShow` attempt. Found while supporting (#2454), although this is not a fix for this (already fixed) issue. (#2463)
+- Changed `NetworkTransform` authority handles delta checks on each new network tick and no longer consumes processing cycles checking for deltas for all frames in-between ticks. (#2388)
+- Changed the `NetworkTransformState` structure is now public and now has public methods that provide access to key properties of the `NetworkTransformState` structure. (#2388)
+- Changed `NetworkTransform` interpolation adjusts its interpolation "ticks ago" to be 2 ticks latent if it is owner authoritative and the instance is not the server or 1 tick latent if the instance is the server and/or is server authoritative. (#2388)
+- Updated `NetworkSceneManager` to migrate dynamically spawned `NetworkObject`s with `DestroyWithScene` set to false into the active scene if their current scene is unloaded. (#2383)
+- Updated the server to synchronize its local `NetworkSceneManager.ClientSynchronizationMode` during the initial client synchronization. (#2383)
+
+### Fixed
+
+- Fixed issue where during client synchronization the synchronizing client could receive a ObjectSceneChanged message before the client-side NetworkObject instance had been instantiated and spawned. (#2502)
+- Fixed issue where `NetworkAnimator` was building client RPC parameters to exclude the host from sending itself messages but was not including it in the ClientRpc parameters. (#2492)
+- Fixed issue where `NetworkAnimator` was not properly detecting and synchronizing cross fade initiated transitions. (#2481)
+- Fixed issue where `NetworkAnimator` was not properly synchronizing animation state updates. (#2481)
+- Fixed float NetworkVariables not being rendered properly in the inspector of NetworkObjects. (#2441)
+- Fixed an issue where Named Message Handlers could remove themselves causing an exception when the metrics tried to access the name of the message.(#2426)
+- Fixed registry of public `NetworkVariable`s in derived `NetworkBehaviour`s (#2423)
+- Fixed issue where runtime association of `Animator` properties to `AnimationCurve`s would cause `NetworkAnimator` to attempt to update those changes. (#2416)
+- Fixed issue where `NetworkAnimator` would not check if its associated `Animator` was valid during serialization and would spam exceptions in the editor console. (#2416)
+- Fixed issue with a child's rotation rolling over when interpolation is enabled on a `NetworkTransform`. Now using half precision or full quaternion synchronization will always update all axis. (#2388)
+- Fixed issue where `NetworkTransform` was not setting the teleport flag when the `NetworkTransform.InLocalSpace` value changed. This issue only impacted `NetworkTransform` when interpolation was enabled. (#2388)
+- Fixed issue when the `NetworkSceneManager.ClientSynchronizationMode` is `LoadSceneMode.Additive` and the server changes the currently active scene prior to a client connecting then upon a client connecting and being synchronized the NetworkSceneManager would clear its internal ScenePlacedObjects list that could already be populated. (#2383)
+- Fixed issue where a client would load duplicate scenes of already preloaded scenes during the initial client synchronization and `NetworkSceneManager.ClientSynchronizationMode` was set to `LoadSceneMode.Additive`. (#2383)
+
+## [1.3.1] - 2023-03-27
+
+### Added
+
+- Added detection and graceful handling of corrupt packets for additional safety. (#2419)
+
+### Changed
+
+- The UTP component UI has been updated to be more user-friendly for new users by adding a simple toggle to switch between local-only (127.0.0.1) and remote (0.0.0.0) binding modes, using the toggle "Allow Remote Connections" (#2408)
+- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.3. (#2450)
+- `NetworkShow()` of `NetworkObject`s are delayed until the end of the frame to ensure consistency of delta-driven variables like `NetworkList`.
+- Dirty `NetworkObject` are reset at end-of-frame and not at serialization time.
+- `NetworkHide()` of an object that was just `NetworkShow()`n produces a warning, as remote clients will _not_ get a spawn/despawn pair.
+- Renamed the NetworkTransform.SetState parameter `shouldGhostsInterpolate` to `teleportDisabled` for better clarity of what that parameter does. (#2228)
+- Network prefabs are now stored in a ScriptableObject that can be shared between NetworkManagers, and have been exposed for public access. By default, a Default Prefabs List is created that contains all NetworkObject prefabs in the project, and new NetworkManagers will default to using that unless that option is turned off in the Netcode for GameObjects settings. Existing NetworkManagers will maintain their existing lists, which can be migrated to the new format via a button in their inspector. (#2322)
+
+### Fixed
+
+- Fixed issue where changes to a layer's weight would not synchronize unless a state transition was occurring.(#2399)
+- Fixed issue where `NetworkManager.LocalClientId` was returning the `NetworkTransport.ServerClientId` as opposed to the `NetworkManager.m_LocalClientId`. (#2398)
+- Fixed issue where a dynamically spawned `NetworkObject` parented under an in-scene placed `NetworkObject` would have its `InScenePlaced` value changed to `true`. This would result in a soft synchronization error for late joining clients. (#2396)
+- Fixed a UTP test that was failing when you install Unity Transport package 2.0.0 or newer. (#2347)
+- Fixed issue where `NetcodeSettingsProvider` would throw an exception in Unity 2020.3.x versions. (#2345)
+- Fixed server side issue where, depending upon component ordering, some NetworkBehaviour components might not have their OnNetworkDespawn method invoked if the client side disconnected. (#2323)
+- Fixed a case where data corruption could occur when using UnityTransport when reaching a certain level of send throughput. (#2332)
+- Fixed an issue in `UnityTransport` where an exception would be thrown if starting a Relay host/server on WebGL. This exception should only be thrown if using direct connections (where WebGL can't act as a host/server). (#2321)
+- Fixed `NetworkAnimator` issue where it was not checking for `AnimatorStateTtansition.destinationStateMachine` and any possible sub-states defined within it. (#2309)
+- Fixed `NetworkAnimator` issue where the host client was receiving the ClientRpc animation updates when the host was the owner.(#2309)
+- Fixed `NetworkAnimator` issue with using pooled objects and when specific properties are cleaned during despawn and destroy.(#2309)
+- Fixed issue where `NetworkAnimator` was checking for animation changes when the associated `NetworkObject` was not spawned.(#2309)
+- Corrected an issue with the documentation for BufferSerializer (#2401)
+
 ## [1.2.0] - 2022-11-21
 
 ### Added
@@ -22,7 +103,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Optimized bandwidth usage by encoding most integer fields using variable-length encoding. (#2276)
 
 ### Fixed
-
+- Fixed `IsSpawnedObjectsPendingInDontDestroyOnLoad` is only set to true when loading a scene using `LoadSceneMode.Singleonly`. (#2330)
 - Fixed issue where `NetworkTransform` components nested under a parent with a `NetworkObject` component  (i.e. network prefab) would not have their associated `GameObject`'s transform synchronized. (#2298)
 - Fixed issue where `NetworkObject`s that failed to instantiate could cause the entire synchronization pipeline to be disrupted/halted for a connecting client. (#2298)
 - Fixed issue where in-scene placed `NetworkObject`s nested under a `GameObject` would be added to the orphaned children list causing continual console warning log messages. (#2298)

Components/AssemblyInfo.cs

@@ -1,10 +1,15 @@
 using System.Runtime.CompilerServices;
 
 #if UNITY_EDITOR
-[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
-[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
 [assembly: InternalsVisibleTo("Unity.Netcode.Editor")]
-[assembly: InternalsVisibleTo("TestProject.EditorTests")]
+[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
-[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
+#endif // UNITY_EDITOR
-#endif
+
+#if UNITY_INCLUDE_TESTS
 [assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")]
+[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
+#if UNITY_EDITOR
+[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
+[assembly: InternalsVisibleTo("TestProject.EditorTests")]
+#endif // UNITY_EDITOR
+#endif // UNITY_INCLUDE_TESTS

Components/HalfVector3.cs

@@ -0,0 +1,159 @@
+using System.Runtime.CompilerServices;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// Half float precision <see cref="Vector3"/>.
+    /// </summary>
+    /// <remarks>
+    /// The Vector3T<ushort> values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
+    /// individual axis and the 16 bits of the half float are stored as <see cref="ushort"/> values since C# does not have
+    /// a half float type.
+    /// </remarks>
+    public struct HalfVector3 : INetworkSerializable
+    {
+        internal const int Length = 3;
+
+        /// <summary>
+        /// The half float precision value of the x-axis as a <see cref="half"/>.
+        /// </summary>
+        public half X => Axis.x;
+        /// <summary>
+        /// The half float precision value of the y-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Y => Axis.y;
+        /// <summary>
+        /// The half float precision value of the z-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Z => Axis.x;
+
+        /// <summary>
+        /// Used to store the half float precision values as a <see cref="half3"/>
+        /// </summary>
+        public half3 Axis;
+
+        /// <summary>
+        /// Determine which axis will be synchronized during serialization
+        /// </summary>
+        public bool3 AxisToSynchronize;
+
+        private void SerializeWrite(FastBufferWriter writer)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    writer.WriteUnmanagedSafe(Axis[i]);
+                }
+            }
+        }
+
+        private void SerializeRead(FastBufferReader reader)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    var axisValue = Axis[i];
+                    reader.ReadUnmanagedSafe(out axisValue);
+                    Axis[i] = axisValue;
+                }
+            }
+        }
+
+        /// <summary>
+        /// The serialization implementation of <see cref="INetworkSerializable"/>.
+        /// </summary>
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            if (serializer.IsReader)
+            {
+                SerializeRead(serializer.GetFastBufferReader());
+            }
+            else
+            {
+                SerializeWrite(serializer.GetFastBufferWriter());
+            }
+        }
+
+        /// <summary>
+        /// Gets the full precision value as a <see cref="Vector3"/>.
+        /// </summary>
+        /// <returns>a <see cref="Vector3"/> as the full precision value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 ToVector3()
+        {
+            Vector3 fullPrecision = Vector3.zero;
+            Vector3 fullConversion = math.float3(Axis);
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    fullPrecision[i] = fullConversion[i];
+                }
+            }
+            return fullPrecision;
+        }
+
+        /// <summary>
+        /// Converts a full precision <see cref="Vector3"/> to half precision and updates the current instance.
+        /// </summary>
+        /// <param name="vector3">The <see cref="Vector3"/> to convert.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Vector3 vector3)
+        {
+            var half3Full = math.half3(vector3);
+            for (int i = 0; i < Length; i++)
+            {
+                if (AxisToSynchronize[i])
+                {
+                    Axis[i] = half3Full[i];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
+        /// <param name="vector3AxisToSynchronize">The axis to synchronize.</param>
+        public HalfVector3(Vector3 vector3, bool3 axisToSynchronize)
+        {
+            Axis = half3.zero;
+            AxisToSynchronize = axisToSynchronize;
+            UpdateFrom(ref vector3);
+        }
+
+        /// <summary>
+        /// Constructor that defaults to all axis being synchronized.
+        /// </summary>
+        /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
+        public HalfVector3(Vector3 vector3) : this(vector3, math.bool3(true))
+        {
+
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
+        /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
+        /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
+        /// <param name="axisToSynchronize">The axis to synchronize.</param>
+        public HalfVector3(float x, float y, float z, bool3 axisToSynchronize) : this(new Vector3(x, y, z), axisToSynchronize)
+        {
+        }
+
+        /// <summary>
+        /// Constructor that defaults to all axis being synchronized.
+        /// </summary>
+        /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
+        /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
+        /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
+        public HalfVector3(float x, float y, float z) : this(new Vector3(x, y, z), math.bool3(true))
+        {
+        }
+    }
+}

Components/HalfVector3.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b0e371533eaeac446b16b10886f64f84
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Components/HalfVector4.cs

@@ -0,0 +1,137 @@
+using System.Runtime.CompilerServices;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// Half Precision <see cref="Vector4"/> that can also be used to convert a <see cref="Quaternion"/> to half precision.
+    /// </summary>
+    /// <remarks>
+    /// The Vector4T<ushort> values are half float values returned by <see cref="Mathf.FloatToHalf(float)"/> for each
+    /// individual axis and the 16 bits of the half float are stored as <see cref="ushort"/> values since C# does not have
+    /// a half float type.
+    /// </remarks>
+    public struct HalfVector4 : INetworkSerializable
+    {
+        internal const int Length = 4;
+        /// <summary>
+        /// The half float precision value of the x-axis as a <see cref="half"/>.
+        /// </summary>
+        public half X => Axis.x;
+
+        /// <summary>
+        /// The half float precision value of the y-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Y => Axis.y;
+
+        /// <summary>
+        /// The half float precision value of the z-axis as a <see cref="half"/>.
+        /// </summary>
+        public half Z => Axis.z;
+
+        /// <summary>
+        /// The half float precision value of the w-axis as a <see cref="half"/>.
+        /// </summary>
+        public half W => Axis.w;
+
+        /// <summary>
+        /// Used to store the half float precision values as a <see cref="half4"/>
+        /// </summary>
+        public half4 Axis;
+
+        private void SerializeWrite(FastBufferWriter writer)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                writer.WriteUnmanagedSafe(Axis[i]);
+            }
+        }
+
+        private void SerializeRead(FastBufferReader reader)
+        {
+            for (int i = 0; i < Length; i++)
+            {
+                var axisValue = Axis[i];
+                reader.ReadUnmanagedSafe(out axisValue);
+                Axis[i] = axisValue;
+            }
+        }
+
+        /// <summary>
+        /// The serialization implementation of <see cref="INetworkSerializable"/>.
+        /// </summary>
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            if (serializer.IsReader)
+            {
+                SerializeRead(serializer.GetFastBufferReader());
+            }
+            else
+            {
+                SerializeWrite(serializer.GetFastBufferWriter());
+            }
+        }
+
+        /// <summary>
+        /// Converts this instance to a full precision <see cref="Vector4"/>.
+        /// </summary>
+        /// <returns>A <see cref="Vector4"/> as the full precision value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector4 ToVector4()
+        {
+            return math.float4(Axis);
+        }
+
+        /// <summary>
+        /// Converts this instance to a full precision <see cref="Quaternion"/>.
+        /// </summary>
+        /// <returns>A <see cref="Quaternion"/> as the full precision value.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Quaternion ToQuaternion()
+        {
+            return math.quaternion(Axis);
+        }
+
+        /// <summary>
+        /// Converts a full precision <see cref="Vector4"/> to half precision and updates the current instance.
+        /// </summary>
+        /// <param name="vector4">The <see cref="Vector4"/> to convert and update this instance with.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Vector4 vector4)
+        {
+            Axis = math.half4(vector4);
+        }
+
+        /// <summary>
+        /// Converts a full precision <see cref="Vector4"/> to half precision and updates the current instance.
+        /// </summary>
+        /// <param name="quaternion">The <see cref="Quaternion"/> to convert and update this instance with.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Quaternion quaternion)
+        {
+            Axis = math.half4(math.half(quaternion.x), math.half(quaternion.y), math.half(quaternion.z), math.half(quaternion.w));
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="vector4">The initial axial values (converted to half floats) when instantiated.</param>
+        public HalfVector4(Vector4 vector4)
+        {
+            Axis = default;
+            UpdateFrom(ref vector4);
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
+        /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
+        /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
+        /// <param name="w">The initial w axis (converted to half float) value when instantiated.</param>
+        public HalfVector4(float x, float y, float z, float w) : this(new Vector4(x, y, z, w))
+        {
+        }
+    }
+}

Components/HalfVector4.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 03c78136f41ff84499e2a6ac4a7dd7a5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Components/Interpolator/BufferedLinearInterpolator.cs

@@ -312,20 +312,79 @@ namespace Unity.Netcode
     /// </remarks>
     public class BufferedLinearInterpolatorQuaternion : BufferedLinearInterpolator<Quaternion>
     {
+        /// <summary>
+        /// Use <see cref="Quaternion.Slerp"/> when <see cref="true"/>.
+        /// Use <see cref="Quaternion.Lerp"/> when <see cref="false"/>
+        /// </summary>
+        /// <remarks>
+        /// When using half precision (due to the imprecision) using <see cref="Quaternion.Lerp"/> is
+        /// less processor intensive (i.e. precision is already "imprecise").
+        /// When using full precision (to maintain precision) using <see cref="Quaternion.Slerp"/> is
+        /// more processor intensive yet yields more precise results.
+        /// </remarks>
+        public bool IsSlerp;
+
         /// <inheritdoc />
         protected override Quaternion InterpolateUnclamped(Quaternion start, Quaternion end, float time)
         {
-            // Disabling Extrapolation:
+            if (IsSlerp)
-            // TODO: Add Jira Ticket
+            {
-            return Quaternion.Slerp(start, end, time);
+                return Quaternion.Slerp(start, end, time);
+            }
+            else
+            {
+                return Quaternion.Lerp(start, end, time);
+            }
         }
 
         /// <inheritdoc />
         protected override Quaternion Interpolate(Quaternion start, Quaternion end, float time)
         {
-            // Disabling Extrapolation:
+            if (IsSlerp)
-            // TODO: Add Jira Ticket
+            {
-            return Quaternion.Slerp(start, end, time);
+                return Quaternion.Slerp(start, end, time);
+            }
+            else
+            {
+                return Quaternion.Lerp(start, end, time);
+            }
+        }
+    }
+
+    /// <summary>
+    /// A <see cref="BufferedLinearInterpolator<T>"/> <see cref="Vector3"/> implementation.
+    /// </summary>
+    public class BufferedLinearInterpolatorVector3 : BufferedLinearInterpolator<Vector3>
+    {
+        /// <summary>
+        /// Use <see cref="Vector3.Slerp"/> when <see cref="true"/>.
+        /// Use <see cref="Vector3.Lerp"/> when <see cref="false"/>
+        /// </summary>
+        public bool IsSlerp;
+        /// <inheritdoc />
+        protected override Vector3 InterpolateUnclamped(Vector3 start, Vector3 end, float time)
+        {
+            if (IsSlerp)
+            {
+                return Vector3.Slerp(start, end, time);
+            }
+            else
+            {
+                return Vector3.Lerp(start, end, time);
+            }
+        }
+
+        /// <inheritdoc />
+        protected override Vector3 Interpolate(Vector3 start, Vector3 end, float time)
+        {
+            if (IsSlerp)
+            {
+                return Vector3.Slerp(start, end, time);
+            }
+            else
+            {
+                return Vector3.Lerp(start, end, time);
+            }
         }
     }
 }

Components/NetworkDeltaPosition.cs

@@ -0,0 +1,205 @@
+using System.Runtime.CompilerServices;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+    /// <summary>
+    /// Used to synchromnize delta position when half float precision is enabled
+    /// </summary>
+    public struct NetworkDeltaPosition : INetworkSerializable
+    {
+        internal const float MaxDeltaBeforeAdjustment = 64f;
+
+        /// <summary>
+        /// The HalfVector3 used to synchronize the delta in position
+        /// </summary>
+        public HalfVector3 HalfVector3;
+
+        internal Vector3 CurrentBasePosition;
+        internal Vector3 PrecisionLossDelta;
+        internal Vector3 HalfDeltaConvertedBack;
+        internal Vector3 PreviousPosition;
+        internal Vector3 DeltaPosition;
+        internal int NetworkTick;
+
+        /// <summary>
+        /// The serialization implementation of <see cref="INetworkSerializable"/>
+        /// </summary>
+        public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
+        {
+            HalfVector3.NetworkSerialize(serializer);
+        }
+
+        /// <summary>
+        /// Gets the full precision value of Vector3 position while also potentially updating the current base position.
+        /// </summary>
+        /// <param name="networkTick">Use the current network tick value.</param>
+        /// <returns>The full position as a <see cref="Vector3"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 ToVector3(int networkTick)
+        {
+            // When synchronizing, it is possible to have a state update arrive
+            // for the same synchronization network tick.  Under this scenario,
+            // we only want to return the existing CurrentBasePosition + DeltaPosition
+            // values and not process the X, Y, or Z values.
+            // (See the constructors below)
+            if (networkTick == NetworkTick)
+            {
+                return CurrentBasePosition + DeltaPosition;
+            }
+            for (int i = 0; i < HalfVector3.Length; i++)
+            {
+                if (HalfVector3.AxisToSynchronize[i])
+                {
+                    DeltaPosition[i] = Mathf.HalfToFloat(HalfVector3.Axis[i].value);
+                    // If we exceed or are equal to the maximum delta value then we need to
+                    // apply the delta to the CurrentBasePosition value and reset the delta
+                    // position for the axis.
+                    if (Mathf.Abs(DeltaPosition[i]) >= MaxDeltaBeforeAdjustment)
+                    {
+                        CurrentBasePosition[i] += DeltaPosition[i];
+                        DeltaPosition[i] = 0.0f;
+                        HalfVector3.Axis[i] = half.zero;
+                    }
+                }
+            }
+            return CurrentBasePosition + DeltaPosition;
+        }
+
+        /// <summary>
+        /// Returns the current base position (excluding the delta position offset).
+        /// </summary>
+        /// <returns>The current base position as a <see cref="Vector3"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetCurrentBasePosition()
+        {
+            return CurrentBasePosition;
+        }
+
+        /// <summary>
+        /// Returns the full position which includes the delta offset position.
+        /// </summary>
+        /// <returns>The full position as a <see cref="Vector3"/>.</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetFullPosition()
+        {
+            return CurrentBasePosition + DeltaPosition;
+        }
+
+        /// <summary>
+        /// The half float vector3 version of the current delta position.
+        /// </summary>
+        /// <remarks>
+        /// Only applies to the authoritative side for <see cref="NetworkTransform"/> instances.
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetConvertedDelta()
+        {
+            return HalfDeltaConvertedBack;
+        }
+
+        /// <summary>
+        /// The full precision current delta position.
+        /// </summary>
+        /// <remarks>
+        /// Authoritative: Will have no precision loss
+        /// Non-Authoritative: Has the current network tick's loss of precision.
+        /// Precision loss adjustments are one network tick behind on the
+        /// non-authoritative side.
+        /// </remarks>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetDeltaPosition()
+        {
+            return DeltaPosition;
+        }
+
+        /// <summary>
+        /// Updates the position delta based off of the current base position.
+        /// </summary>
+        /// <param name="vector3">The full precision <see cref="Vector3"/> value to (converted to half floats) used to determine the delta offset positon.</param>
+        /// <param name="networkTick">Set the current network tick value when updating.</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UpdateFrom(ref Vector3 vector3, int networkTick)
+        {
+            NetworkTick = networkTick;
+            DeltaPosition = (vector3 + PrecisionLossDelta) - CurrentBasePosition;
+            for (int i = 0; i < HalfVector3.Length; i++)
+            {
+                if (HalfVector3.AxisToSynchronize[i])
+                {
+                    HalfVector3.Axis[i] = math.half(DeltaPosition[i]);
+                    HalfDeltaConvertedBack[i] = Mathf.HalfToFloat(HalfVector3.Axis[i].value);
+                    PrecisionLossDelta[i] = DeltaPosition[i] - HalfDeltaConvertedBack[i];
+                    if (Mathf.Abs(HalfDeltaConvertedBack[i]) >= MaxDeltaBeforeAdjustment)
+                    {
+                        CurrentBasePosition[i] += HalfDeltaConvertedBack[i];
+                        HalfDeltaConvertedBack[i] = 0.0f;
+                        DeltaPosition[i] = 0.0f;
+                    }
+                }
+            }
+
+            for (int i = 0; i < HalfVector3.Length; i++)
+            {
+                if (HalfVector3.AxisToSynchronize[i])
+                {
+                    PreviousPosition[i] = vector3[i];
+                }
+            }
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
+        /// <param name="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        /// <param name="axisToSynchronize">The axis to be synchronized.</param>
+        public NetworkDeltaPosition(Vector3 vector3, int networkTick, bool3 axisToSynchronize)
+        {
+            NetworkTick = networkTick;
+            CurrentBasePosition = vector3;
+            PreviousPosition = vector3;
+            PrecisionLossDelta = Vector3.zero;
+            DeltaPosition = Vector3.zero;
+            HalfDeltaConvertedBack = Vector3.zero;
+            HalfVector3 = new HalfVector3(vector3, axisToSynchronize);
+            UpdateFrom(ref vector3, networkTick);
+        }
+
+        /// <summary>
+        /// Constructor that defaults to all axis being synchronized.
+        /// </summary>
+        /// <param name="vector3">The initial axial values (converted to half floats) when instantiated.</param>
+        /// <param name="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        public NetworkDeltaPosition(Vector3 vector3, int networkTick) : this(vector3, networkTick, math.bool3(true))
+        {
+
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
+        /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
+        /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
+        /// <param name="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        /// <param name="axisToSynchronize">The axis to be synchronized.</param>
+        public NetworkDeltaPosition(float x, float y, float z, int networkTick, bool3 axisToSynchronize) :
+            this(new Vector3(x, y, z), networkTick, axisToSynchronize)
+        {
+        }
+
+        /// <summary>
+        /// Constructor
+        /// </summary>
+        /// <param name="x">The initial x axis (converted to half float) value when instantiated.</param>
+        /// <param name="y">The initial y axis (converted to half float) value when instantiated.</param>
+        /// <param name="z">The initial z axis (converted to half float) value when instantiated.</param>
+        /// <param name="networkTick">Set the network tick value to the current network tick when instantiating.</param>
+        public NetworkDeltaPosition(float x, float y, float z, int networkTick) :
+            this(new Vector3(x, y, z), networkTick, math.bool3(true))
+        {
+        }
+    }
+}

Components/NetworkDeltaPosition.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e45e6886578116f4c92fa0fe0d77fb85
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Components/QuaternionCompressor.cs

@@ -0,0 +1,123 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// A Smallest Three Quaternion Compressor Implementation
+    /// </summary>
+    /// <remarks>
+    /// Explanation of why "The smallest three":
+    /// Since a normalized Quaternion's unit value is 1.0f:
+    /// x*x + y*y + z*z + w*w = M*M (where M is the magnitude of the vector)
+    /// If w was the largest value and the quaternion is normalized:
+    /// M = 1.0f (which M * M would still yield 1.0f)
+    /// w*w = M*M - (x*x + y*y + z*z) or Mathf.Sqrt(1.0f - (x*x + y*y + z*z))
+    /// w = Math.Sqrt(1.0f - (x*x + y*y + z*z))
+    /// Using the largest the number avoids potential loss of precision in the smallest three values.
+    /// </remarks>
+    public static class QuaternionCompressor
+    {
+        private const ushort k_PrecisionMask = (1 << 9) - 1;
+
+        // Square root of 2 over 2 (Mathf.Sqrt(2.0f) / 2.0f == 1.0f / Mathf.Sqrt(2.0f))
+        // This provides encoding the smallest three components into a (+/-) Mathf.Sqrt(2.0f) / 2.0f range
+        private const float k_SqrtTwoOverTwoEncoding = 0.70710678118654752440084436210485f;
+
+        // We can further improve the encoding compression by dividing k_SqrtTwoOverTwo into 1.0f and multiplying that
+        // by the precision mask (minor reduction of runtime calculations)
+        private const float k_CompressionEcodingMask = (1.0f / k_SqrtTwoOverTwoEncoding) * k_PrecisionMask;
+
+        // Used to shift the negative bit to the 10th bit position when compressing and encoding
+        private const ushort k_ShiftNegativeBit = 9;
+
+        // We can do the same for our decoding and decompression by dividing k_PrecisionMask into 1.0 and multiplying
+        // that by k_SqrtTwoOverTwo (minor reduction of runtime calculations)
+        private const float k_DcompressionDecodingMask = (1.0f / k_PrecisionMask) * k_SqrtTwoOverTwoEncoding;
+
+        // The sign bit position (10th bit) used when decompressing and decoding
+        private const ushort k_NegShortBit = 0x200;
+
+        // Negative bit set values
+        private const ushort k_True = 1;
+        private const ushort k_False = 0;
+
+        // Used to store the absolute value of the 4 quaternion elements
+        private static Quaternion s_QuatAbsValues = Quaternion.identity;
+
+        /// <summary>
+        /// Compresses a Quaternion into an unsigned integer
+        /// </summary>
+        /// <param name="quaternion">the <see cref="Quaternion"/> to be compressed</param>
+        /// <returns>the <see cref="Quaternion"/> compressed as an unsigned integer</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static uint CompressQuaternion(ref Quaternion quaternion)
+        {
+            // Store off the absolute value for each Quaternion element
+            s_QuatAbsValues[0] = Mathf.Abs(quaternion[0]);
+            s_QuatAbsValues[1] = Mathf.Abs(quaternion[1]);
+            s_QuatAbsValues[2] = Mathf.Abs(quaternion[2]);
+            s_QuatAbsValues[3] = Mathf.Abs(quaternion[3]);
+
+            // Get the largest element value of the quaternion to know what the remaining "Smallest Three" values are
+            var quatMax = Mathf.Max(s_QuatAbsValues[0], s_QuatAbsValues[1], s_QuatAbsValues[2], s_QuatAbsValues[3]);
+
+            // Find the index of the largest element so we can skip that element while compressing and decompressing
+            var indexToSkip = (ushort)(s_QuatAbsValues[0] == quatMax ? 0 : s_QuatAbsValues[1] == quatMax ? 1 : s_QuatAbsValues[2] == quatMax ? 2 : 3);
+
+            // Get the sign of the largest element which is all that is needed when calculating the sum of squares of a normalized quaternion.
+
+            var quatMaxSign = (quaternion[indexToSkip] < 0 ? k_True : k_False);
+
+            // Start with the index to skip which will be shifted to the highest two bits
+            var compressed = (uint)indexToSkip;
+
+            // Step 1: Start with the first element
+            var currentIndex = 0;
+
+            // Step 2: If we are on the index to skip preserve the current compressed value, otherwise proceed to step 3 and 4
+            // Step 3: Get the sign of the element we are processing. If it is the not the same as the largest value's sign bit then we set the bit
+            // Step 4: Get the compressed and encoded value by multiplying the absolute value of the current element by k_CompressionEcodingMask and round that result up
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+            currentIndex++;
+            // Repeat the last 3 steps for the remaining elements
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+            currentIndex++;
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+            currentIndex++;
+            compressed = currentIndex != indexToSkip ? (compressed << 10) | (uint)((quaternion[currentIndex] < 0 ? k_True : k_False) != quatMaxSign ? k_True : k_False) << k_ShiftNegativeBit | (ushort)Mathf.Round(k_CompressionEcodingMask * s_QuatAbsValues[currentIndex]) : compressed;
+
+            // Return the compress quaternion
+            return compressed;
+        }
+
+        /// <summary>
+        /// Decompress a compressed quaternion
+        /// </summary>
+        /// <param name="quaternion">quaternion to store the decompressed values within</param>
+        /// <param name="compressed">the compressed quaternion</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void DecompressQuaternion(ref Quaternion quaternion, uint compressed)
+        {
+            // Get the last two bits for the index to skip (0-3)
+            var indexToSkip = (int)(compressed >> 30);
+
+            // Reverse out the values while skipping over the largest value index
+            var sumOfSquaredMagnitudes = 0.0f;
+            for (int i = 3; i >= 0; --i)
+            {
+                if (i == indexToSkip)
+                {
+                    continue;
+                }
+                // Check the negative bit and multiply that result with the decompressed and decoded value
+                quaternion[i] = ((compressed & k_NegShortBit) > 0 ? -1.0f : 1.0f) * ((compressed & k_PrecisionMask) * k_DcompressionDecodingMask);
+                sumOfSquaredMagnitudes += quaternion[i] * quaternion[i];
+                compressed = compressed >> 10;
+            }
+            // Since a normalized quaternion's magnitude is 1.0f, we subtract the sum of the squared smallest three from the unit value and take
+            // the square root of the difference to find the final largest value
+            quaternion[indexToSkip] = Mathf.Sqrt(1.0f - sumOfSquaredMagnitudes);
+        }
+    }
+}

Components/QuaternionCompressor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bb9d8b98d3c8bca469c8ee152353336f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Components/com.unity.netcode.components.asmdef

@@ -3,7 +3,8 @@
     "rootNamespace": "Unity.Netcode.Components",
     "references": [
         "Unity.Netcode.Runtime",
-        "Unity.Collections"
+        "Unity.Collections",
+        "Unity.Mathematics"
     ],
     "allowUnsafeCode": true,
     "versionDefines": [

Editor/AssemblyInfo.cs

@@ -1,3 +1,7 @@
 using System.Runtime.CompilerServices;
 
+#if UNITY_INCLUDE_TESTS
+#if UNITY_EDITOR
 [assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
+#endif // UNITY_EDITOR
+#endif // UNITY_INCLUDE_TESTS

Editor/CodeGen/INetworkMessageILPP.cs

@@ -1,7 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Collections.Generic;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Mono.Cecil.Rocks;

Editor/CodeGen/INetworkSerializableILPP.cs

@@ -1,7 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Collections.Generic;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
 using Unity.CompilationPipeline.Common.Diagnostics;

Editor/CodeGen/NetworkBehaviourILPP.cs

@@ -1,7 +1,7 @@
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Collections.Generic;
 using System.Runtime.CompilerServices;
 using Mono.Cecil;
 using Mono.Cecil.Cil;
@@ -9,9 +9,9 @@ using Mono.Cecil.Rocks;
 using Unity.CompilationPipeline.Common.Diagnostics;
 using Unity.CompilationPipeline.Common.ILPostProcessing;
 using UnityEngine;
+using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
 using MethodAttributes = Mono.Cecil.MethodAttributes;
 using ParameterAttributes = Mono.Cecil.ParameterAttributes;
-using ILPPInterface = Unity.CompilationPipeline.Common.ILPostProcessing.ILPostProcessor;
 
 namespace Unity.Netcode.Editor.CodeGen
 {
@@ -837,6 +837,58 @@ namespace Unity.Netcode.Editor.CodeGen
             GetAllFieldsAndResolveGenerics(resolved, ref fieldTypes, genericParams);
         }
 
+        private void GetAllBaseTypesAndResolveGenerics(TypeDefinition type, ref List<TypeReference> baseTypes, Dictionary<string, TypeReference> genericParameters)
+        {
+
+            if (type == null || type.BaseType == null || type.BaseType.Name == "Object")
+            {
+                return;
+            }
+
+            var baseType = type.BaseType;
+
+            var genericParams = new Dictionary<string, TypeReference>();
+
+            if (baseType.IsGenericInstance)
+            {
+                var genericType = (GenericInstanceType)baseType;
+                var newGenericType = new GenericInstanceType(baseType.Resolve());
+                for (var i = 0; i < genericType.GenericArguments.Count; ++i)
+                {
+                    var argument = genericType.GenericArguments[i];
+
+                    if (genericParameters != null && genericParameters.ContainsKey(argument.Name))
+                    {
+                        newGenericType.GenericArguments.Add(genericParameters[argument.Name]);
+                        genericParams[baseType.Resolve().GenericParameters[newGenericType.GenericArguments.Count - 1].Name] = genericParameters[argument.Name];
+                    }
+                    else
+                    {
+                        newGenericType.GenericArguments.Add(argument);
+                    }
+                }
+                baseTypes.Add(newGenericType);
+            }
+            else
+            {
+                baseTypes.Add(baseType);
+            }
+
+            var resolved = type.BaseType.Resolve();
+            if (type.BaseType.IsGenericInstance)
+            {
+                var genericType = (GenericInstanceType)type.BaseType;
+                for (var i = 0; i < genericType.GenericArguments.Count; ++i)
+                {
+                    if (!genericParams.ContainsKey(resolved.GenericParameters[i].Name))
+                    {
+                        genericParams[resolved.GenericParameters[i].Name] = genericType.GenericArguments[i];
+                    }
+                }
+            }
+            GetAllBaseTypesAndResolveGenerics(resolved, ref baseTypes, genericParams);
+        }
+
         private void ProcessNetworkBehaviour(TypeDefinition typeDefinition, string[] assemblyDefines)
         {
             var rpcHandlers = new List<(uint RpcMethodId, MethodDefinition RpcHandler)>();
@@ -898,6 +950,34 @@ namespace Unity.Netcode.Editor.CodeGen
                             }
                         }
                     }
+                    {
+                        var baseTypes = new List<TypeReference>();
+
+                        var genericParams = new Dictionary<string, TypeReference>();
+                        var resolved = type.Resolve();
+                        if (type.IsGenericInstance)
+                        {
+                            var genericType = (GenericInstanceType)type;
+                            for (var i = 0; i < genericType.GenericArguments.Count; ++i)
+                            {
+                                genericParams[resolved.GenericParameters[i].Name] = genericType.GenericArguments[i];
+                            }
+                        }
+
+                        GetAllBaseTypesAndResolveGenerics(type.Resolve(), ref baseTypes, genericParams);
+                        foreach (var baseType in baseTypes)
+                        {
+                            if (baseType.Resolve().Name == typeof(NetworkVariable<>).Name || baseType.Resolve().Name == typeof(NetworkList<>).Name)
+                            {
+                                var genericInstanceType = (GenericInstanceType)baseType;
+                                var wrappedType = genericInstanceType.GenericArguments[0];
+                                if (!m_WrappedNetworkVariableTypes.Contains(wrappedType))
+                                {
+                                    m_WrappedNetworkVariableTypes.Add(wrappedType);
+                                }
+                            }
+                        }
+                    }
                 }
             }
 

Editor/Configuration.meta

@@ -1,8 +1,3 @@
 fileFormatVersion: 2
-guid: 52153943c346dd04e8712ab540ab9c22
+guid: b2f70916f7024c66aa5dfe1e43c151a2
-folderAsset: yes
+timeCreated: 1654274400
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Editor/Configuration/NetcodeForGameObjectsSettings.cs

@@ -1,9 +1,10 @@
 using UnityEditor;
+using UnityEngine;
 
 
 namespace Unity.Netcode.Editor.Configuration
 {
-    internal class NetcodeForGameObjectsSettings
+    internal class NetcodeForGameObjectsEditorSettings
     {
         internal const string AutoAddNetworkObjectIfNoneExists = "AutoAdd-NetworkObject-When-None-Exist";
         internal const string InstallMultiplayerToolsTipDismissedPlayerPrefKey = "Netcode_Tip_InstallMPTools_Dismissed";
@@ -14,6 +15,7 @@ namespace Unity.Netcode.Editor.Configuration
             {
                 return EditorPrefs.GetInt(InstallMultiplayerToolsTipDismissedPlayerPrefKey);
             }
+
             return 0;
         }
 
@@ -28,6 +30,7 @@ namespace Unity.Netcode.Editor.Configuration
             {
                 return EditorPrefs.GetBool(AutoAddNetworkObjectIfNoneExists);
             }
+
             return false;
         }
 
@@ -36,4 +39,15 @@ namespace Unity.Netcode.Editor.Configuration
             EditorPrefs.SetBool(AutoAddNetworkObjectIfNoneExists, autoAddSetting);
         }
     }
+
+    [FilePath("ProjectSettings/NetcodeForGameObjects.settings", FilePathAttribute.Location.ProjectFolder)]
+    internal class NetcodeForGameObjectsProjectSettings : ScriptableSingleton<NetcodeForGameObjectsProjectSettings>
+    {
+        [SerializeField] public bool GenerateDefaultNetworkPrefabs = true;
+
+        internal void SaveSettings()
+        {
+            Save(true);
+        }
+    }
 }

Editor/Configuration/NetcodeSettingsProvider.cs

@@ -5,6 +5,11 @@ namespace Unity.Netcode.Editor.Configuration
 {
     internal static class NetcodeSettingsProvider
     {
+        private const float k_MaxLabelWidth = 450f;
+        private static float s_MaxLabelWidth;
+        private static bool s_ShowEditorSettingFields = true;
+        private static bool s_ShowProjectSettingFields = true;
+
         [SettingsProvider]
         public static SettingsProvider CreateNetcodeSettingsProvider()
         {
@@ -20,25 +25,105 @@ namespace Unity.Netcode.Editor.Configuration
             return provider;
         }
 
-        internal static NetcodeSettingsLabel NetworkObjectsSectionLabel = new NetcodeSettingsLabel("NetworkObject Helper Settings", 20);
+
-        internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle = new NetcodeSettingsToggle("Auto-Add NetworkObjects", "When enabled, NetworkObjects are automatically added to GameObjects when NetworkBehaviours are added first.", 20);
+        internal static NetcodeSettingsLabel NetworkObjectsSectionLabel;
-        internal static NetcodeSettingsLabel MultiplayerToolsLabel = new NetcodeSettingsLabel("Multiplayer Tools", 20);
+        internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle;
-        internal static NetcodeSettingsToggle MultiplayerToolTipStatusToggle = new NetcodeSettingsToggle("Multiplayer Tools Install Reminder", "When enabled, the NetworkManager will display " +
+        internal static NetcodeSettingsLabel MultiplayerToolsLabel;
-            "the notification to install the multiplayer tools package.", 20);
+        internal static NetcodeSettingsToggle MultiplayerToolTipStatusToggle;
+
+        /// <summary>
+        /// Creates an instance of the settings UI Elements if they don't already exist.
+        /// </summary>
+        /// <remarks>
+        /// We have to construct any NetcodeGUISettings derived classes here because in
+        /// version 2020.x.x EditorStyles.label does not exist yet (higher versions it does)
+        /// </remarks>
+        private static void CheckForInitialize()
+        {
+            if (NetworkObjectsSectionLabel == null)
+            {
+                NetworkObjectsSectionLabel = new NetcodeSettingsLabel("NetworkObject Helper Settings", 20);
+            }
+
+            if (AutoAddNetworkObjectToggle == null)
+            {
+                AutoAddNetworkObjectToggle = new NetcodeSettingsToggle("Auto-Add NetworkObject Component", "When enabled, NetworkObject components are automatically added to GameObjects when NetworkBehaviour components are added first.", 20);
+            }
+
+            if (MultiplayerToolsLabel == null)
+            {
+                MultiplayerToolsLabel = new NetcodeSettingsLabel("Multiplayer Tools", 20);
+            }
+
+            if (MultiplayerToolTipStatusToggle == null)
+            {
+                MultiplayerToolTipStatusToggle = new NetcodeSettingsToggle("Multiplayer Tools Install Reminder", "When enabled, the NetworkManager will display the notification to install the multiplayer tools package.", 20);
+            }
+        }
 
         private static void OnGuiHandler(string obj)
         {
-            var autoAddNetworkObjectSetting = NetcodeForGameObjectsSettings.GetAutoAddNetworkObjectSetting();
+            // Make sure all NetcodeGUISettings derived classes are instantiated first
-            var multiplayerToolsTipStatus = NetcodeForGameObjectsSettings.GetNetcodeInstallMultiplayerToolTips() == 0;
+            CheckForInitialize();
+
+            var autoAddNetworkObjectSetting = NetcodeForGameObjectsEditorSettings.GetAutoAddNetworkObjectSetting();
+            var multiplayerToolsTipStatus = NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() == 0;
+            var settings = NetcodeForGameObjectsProjectSettings.instance;
+            var generateDefaultPrefabs = settings.GenerateDefaultNetworkPrefabs;
+
             EditorGUI.BeginChangeCheck();
-            NetworkObjectsSectionLabel.DrawLabel();
+
-            autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting);
+            GUILayout.BeginVertical("Box");
-            MultiplayerToolsLabel.DrawLabel();
+            s_ShowEditorSettingFields = EditorGUILayout.BeginFoldoutHeaderGroup(s_ShowEditorSettingFields, "Editor Settings");
-            multiplayerToolsTipStatus = MultiplayerToolTipStatusToggle.DrawToggle(multiplayerToolsTipStatus);
+
+            if (s_ShowEditorSettingFields)
+            {
+                GUILayout.BeginVertical("Box");
+                NetworkObjectsSectionLabel.DrawLabel();
+                autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting);
+                GUILayout.EndVertical();
+
+                GUILayout.BeginVertical("Box");
+                MultiplayerToolsLabel.DrawLabel();
+                multiplayerToolsTipStatus = MultiplayerToolTipStatusToggle.DrawToggle(multiplayerToolsTipStatus);
+                GUILayout.EndVertical();
+            }
+            EditorGUILayout.EndFoldoutHeaderGroup();
+            GUILayout.EndVertical();
+
+            GUILayout.BeginVertical("Box");
+            s_ShowProjectSettingFields = EditorGUILayout.BeginFoldoutHeaderGroup(s_ShowProjectSettingFields, "Project Settings");
+            if (s_ShowProjectSettingFields)
+            {
+                GUILayout.BeginVertical("Box");
+                const string generateNetworkPrefabsString = "Generate Default Network Prefabs List";
+
+                if (s_MaxLabelWidth == 0)
+                {
+                    s_MaxLabelWidth = EditorStyles.label.CalcSize(new GUIContent(generateNetworkPrefabsString)).x;
+                    s_MaxLabelWidth = Mathf.Min(k_MaxLabelWidth, s_MaxLabelWidth);
+                }
+
+                EditorGUIUtility.labelWidth = s_MaxLabelWidth;
+
+                GUILayout.Label("Network Prefabs", EditorStyles.boldLabel);
+                generateDefaultPrefabs = EditorGUILayout.Toggle(
+                    new GUIContent(
+                        generateNetworkPrefabsString,
+                        "When enabled, a default NetworkPrefabsList object will be added to your project and kept up " +
+                        "to date with all NetworkObject prefabs."),
+                    generateDefaultPrefabs,
+                    GUILayout.Width(s_MaxLabelWidth + 20));
+                GUILayout.EndVertical();
+            }
+            EditorGUILayout.EndFoldoutHeaderGroup();
+            GUILayout.EndVertical();
             if (EditorGUI.EndChangeCheck())
             {
-                NetcodeForGameObjectsSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting);
+                NetcodeForGameObjectsEditorSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting);
-                NetcodeForGameObjectsSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1);
+                NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1);
+                settings.GenerateDefaultNetworkPrefabs = generateDefaultPrefabs;
+                settings.SaveSettings();
             }
         }
     }
@@ -56,7 +141,7 @@ namespace Unity.Netcode.Editor.Configuration
         public NetcodeSettingsLabel(string labelText, float layoutOffset = 0.0f)
         {
             m_LabelContent = labelText;
-            AdjustLableSize(labelText, layoutOffset);
+            AdjustLabelSize(labelText, layoutOffset);
         }
     }
 
@@ -72,7 +157,7 @@ namespace Unity.Netcode.Editor.Configuration
 
         public NetcodeSettingsToggle(string labelText, string toolTip, float layoutOffset)
         {
-            AdjustLableSize(labelText, layoutOffset);
+            AdjustLabelSize(labelText, layoutOffset);
             m_ToggleContent = new GUIContent(labelText, toolTip);
         }
     }
@@ -84,7 +169,7 @@ namespace Unity.Netcode.Editor.Configuration
 
         protected GUILayoutOption m_LayoutWidth { get; private set; }
 
-        protected void AdjustLableSize(string labelText, float offset = 0.0f)
+        protected void AdjustLabelSize(string labelText, float offset = 0.0f)
         {
             m_LabelSize = Mathf.Min(k_MaxLabelWidth, EditorStyles.label.CalcSize(new GUIContent(labelText)).x);
             m_LayoutWidth = GUILayout.Width(m_LabelSize + offset);

Editor/Configuration/NetworkPrefabProcessor.cs

@@ -0,0 +1,187 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor.Configuration
+{
+    /// <summary>
+    /// Updates the default <see cref="NetworkPrefabsList"/> instance when prefabs are updated (created, moved, deleted) in the project.
+    /// </summary>
+    public class NetworkPrefabProcessor : AssetPostprocessor
+    {
+        private static string s_DefaultNetworkPrefabsPath = "Assets/DefaultNetworkPrefabs.asset";
+        public static string DefaultNetworkPrefabsPath
+        {
+            get
+            {
+                return s_DefaultNetworkPrefabsPath;
+            }
+            internal set
+            {
+                s_DefaultNetworkPrefabsPath = value;
+                // Force a recache of the prefab list
+                s_PrefabsList = null;
+            }
+        }
+        private static NetworkPrefabsList s_PrefabsList;
+        private static Dictionary<string, NetworkPrefab> s_PrefabsListPath = new Dictionary<string, NetworkPrefab>();
+
+        private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+        {
+            var settings = NetcodeForGameObjectsProjectSettings.instance;
+            if (!settings.GenerateDefaultNetworkPrefabs)
+            {
+                return;
+            }
+
+            bool ProcessImportedAssets(string[] importedAssets1)
+            {
+                var dirty = false;
+                foreach (var assetPath in importedAssets1)
+                {
+                    // We only care about GameObjects, skip everything else. Can't use the more targeted
+                    // OnPostProcessPrefabs since that's not called for moves or deletes
+                    if (AssetDatabase.GetMainAssetTypeAtPath(assetPath) != typeof(GameObject))
+                    {
+                        continue;
+                    }
+
+                    var go = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+                    if (go.TryGetComponent<NetworkObject>(out _))
+                    {
+                        // Make sure we are not duplicating an already existing entry
+                        if (s_PrefabsListPath.ContainsKey(assetPath))
+                        {
+                            // Is the imported asset different from the one we already have in the list?
+                            if (s_PrefabsListPath[assetPath].Prefab.GetHashCode() != go.GetHashCode())
+                            {
+                                // If so remove the one in the list and continue on to add the imported one
+                                s_PrefabsList.List.Remove(s_PrefabsListPath[assetPath]);
+                            }
+                            else // If they are identical, then just ignore the import
+                            {
+                                continue;
+                            }
+                        }
+
+                        s_PrefabsList.List.Add(new NetworkPrefab { Prefab = go });
+                        dirty = true;
+                    }
+                }
+
+                return dirty;
+            }
+
+            bool ProcessDeletedAssets(string[] strings)
+            {
+                var dirty = false;
+                var deleted = new List<string>(strings);
+                for (int i = s_PrefabsList.List.Count - 1; i >= 0 && deleted.Count > 0; --i)
+                {
+                    GameObject prefab;
+                    try
+                    {
+                        prefab = s_PrefabsList.List[i].Prefab;
+                    }
+                    catch (MissingReferenceException)
+                    {
+                        s_PrefabsList.List.RemoveAt(i);
+                        continue;
+                    }
+                    if (prefab == null)
+                    {
+                        s_PrefabsList.List.RemoveAt(i);
+                    }
+                    else
+                    {
+                        string noPath = AssetDatabase.GetAssetPath(prefab);
+                        for (int j = strings.Length - 1; j >= 0; --j)
+                        {
+                            if (noPath == strings[j])
+                            {
+                                s_PrefabsList.List.RemoveAt(i);
+                                deleted.RemoveAt(j);
+                                dirty = true;
+                            }
+                        }
+                    }
+                }
+
+                return dirty;
+            }
+
+            if (s_PrefabsList == null)
+            {
+                s_PrefabsList = GetOrCreateNetworkPrefabs(DefaultNetworkPrefabsPath, out var newList, true);
+                // A new list already processed all existing assets, no need to double-process imports & deletes
+                if (newList)
+                {
+                    return;
+                }
+            }
+            // Clear our asset path to prefab table each time
+            s_PrefabsListPath.Clear();
+
+            // Create our asst path to prefab table
+            foreach (var prefabEntry in s_PrefabsList.List)
+            {
+                if (!s_PrefabsListPath.ContainsKey(AssetDatabase.GetAssetPath(prefabEntry.Prefab)))
+                {
+                    s_PrefabsListPath.Add(AssetDatabase.GetAssetPath(prefabEntry.Prefab), prefabEntry);
+                }
+            }
+
+            // Process the imported and deleted assets
+            var markDirty = ProcessImportedAssets(importedAssets);
+            markDirty &= ProcessDeletedAssets(deletedAssets);
+
+            if (markDirty)
+            {
+                EditorUtility.SetDirty(s_PrefabsList);
+            }
+        }
+
+        internal static NetworkPrefabsList GetOrCreateNetworkPrefabs(string path, out bool isNew, bool addAll)
+        {
+            var defaultPrefabs = AssetDatabase.LoadAssetAtPath<NetworkPrefabsList>(path);
+            if (defaultPrefabs == null)
+            {
+                isNew = true;
+                defaultPrefabs = ScriptableObject.CreateInstance<NetworkPrefabsList>();
+                defaultPrefabs.IsDefault = true;
+                AssetDatabase.CreateAsset(defaultPrefabs, path);
+
+                if (addAll)
+                {
+                    // This could be very expensive in large projects... maybe make it manually triggered via a menu?
+                    defaultPrefabs.List = FindAll();
+                }
+                EditorUtility.SetDirty(defaultPrefabs);
+                AssetDatabase.SaveAssetIfDirty(defaultPrefabs);
+                return defaultPrefabs;
+            }
+
+            isNew = false;
+            return defaultPrefabs;
+        }
+
+        private static List<NetworkPrefab> FindAll()
+        {
+            var list = new List<NetworkPrefab>();
+
+            string[] guids = AssetDatabase.FindAssets("t:GameObject");
+            foreach (var guid in guids)
+            {
+                string assetPath = AssetDatabase.GUIDToAssetPath(guid);
+                var go = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+
+                if (go.TryGetComponent(out NetworkObject _))
+                {
+                    list.Add(new NetworkPrefab { Prefab = go });
+                }
+            }
+
+            return list;
+        }
+    }
+}

Editor/Configuration/NetworkPrefabProcessor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d8b62a05d80cc444f9c74731c01b8e39
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/Configuration/NetworkPrefabsEditor.cs

@@ -0,0 +1,97 @@
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor
+{
+    [CustomEditor(typeof(NetworkPrefabsList), true)]
+    [CanEditMultipleObjects]
+    public class NetworkPrefabsEditor : UnityEditor.Editor
+    {
+        private ReorderableList m_NetworkPrefabsList;
+        private SerializedProperty m_IsDefaultBool;
+
+        private void OnEnable()
+        {
+            m_IsDefaultBool = serializedObject.FindProperty(nameof(NetworkPrefabsList.IsDefault));
+            m_NetworkPrefabsList = new ReorderableList(serializedObject, serializedObject.FindProperty("List"), true, true, true, true);
+            m_NetworkPrefabsList.elementHeightCallback = index =>
+            {
+                var networkOverrideInt = 0;
+                if (m_NetworkPrefabsList.count > 0)
+                {
+                    var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
+                    var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
+                    networkOverrideInt = networkOverrideProp.enumValueIndex;
+                }
+
+                return 8 + (networkOverrideInt == 0 ? EditorGUIUtility.singleLineHeight : (EditorGUIUtility.singleLineHeight * 2) + 5);
+            };
+            m_NetworkPrefabsList.drawElementCallback = (rect, index, isActive, isFocused) =>
+            {
+                rect.y += 5;
+
+                var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
+                var networkPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Prefab));
+                var networkSourceHashProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourceHashToOverride));
+                var networkSourcePrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourcePrefabToOverride));
+                var networkTargetPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.OverridingTargetPrefab));
+                var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
+                var networkOverrideInt = networkOverrideProp.enumValueIndex;
+                var networkOverrideEnum = (NetworkPrefabOverride)networkOverrideInt;
+                EditorGUI.LabelField(new Rect(rect.x + rect.width - 70, rect.y, 60, EditorGUIUtility.singleLineHeight), "Override");
+                if (networkOverrideEnum == NetworkPrefabOverride.None)
+                {
+                    if (EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), false))
+                    {
+                        networkOverrideProp.enumValueIndex = (int)NetworkPrefabOverride.Prefab;
+                    }
+                }
+                else
+                {
+                    if (!EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), true))
+                    {
+                        networkOverrideProp.enumValueIndex = 0;
+                        networkOverrideEnum = NetworkPrefabOverride.None;
+                    }
+                }
+
+                if (networkOverrideEnum == NetworkPrefabOverride.None)
+                {
+                    EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width - 80, EditorGUIUtility.singleLineHeight), networkPrefabProp, GUIContent.none);
+                }
+                else
+                {
+                    networkOverrideProp.enumValueIndex = GUI.Toolbar(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), networkOverrideInt - 1, new[] { "Prefab", "Hash" }) + 1;
+
+                    if (networkOverrideEnum == NetworkPrefabOverride.Prefab)
+                    {
+                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourcePrefabProp, GUIContent.none);
+                    }
+                    else
+                    {
+                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourceHashProp, GUIContent.none);
+                    }
+
+                    rect.y += EditorGUIUtility.singleLineHeight + 5;
+
+                    EditorGUI.LabelField(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), "Overriding Prefab");
+                    EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 110, EditorGUIUtility.singleLineHeight), networkTargetPrefabProp, GUIContent.none);
+                }
+            };
+            m_NetworkPrefabsList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, "NetworkPrefabs");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            using (new EditorGUI.DisabledScope(true))
+            {
+                EditorGUILayout.PropertyField(m_IsDefaultBool);
+            }
+
+            m_NetworkPrefabsList.DoLayoutList();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}

Editor/Configuration/NetworkPrefabsEditor.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8d6d0919fa8ff41c9b1d1241256f7364
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Editor/HiddenScriptEditor.cs

@@ -4,6 +4,7 @@ using Unity.Netcode.Transports.UNET;
 #endif
 using Unity.Netcode.Transports.UTP;
 using UnityEditor;
+using UnityEngine;
 
 namespace Unity.Netcode.Editor
 {
@@ -43,7 +44,109 @@ namespace Unity.Netcode.Editor
     [CustomEditor(typeof(UnityTransport), true)]
     public class UnityTransportEditor : HiddenScriptEditor
     {
+        private static readonly string[] k_HiddenFields = { "m_Script", "ConnectionData" };
 
+        private bool m_AllowIncomingConnections;
+        private bool m_Initialized;
+
+        private UnityTransport m_UnityTransport;
+
+        private SerializedProperty m_ServerAddressProperty;
+        private SerializedProperty m_ServerPortProperty;
+        private SerializedProperty m_OverrideBindIpProperty;
+
+        private const string k_LoopbackIpv4 = "127.0.0.1";
+        private const string k_LoopbackIpv6 = "::1";
+        private const string k_AnyIpv4 = "0.0.0.0";
+        private const string k_AnyIpv6 = "::";
+
+
+        private void Initialize()
+        {
+            if (m_Initialized)
+            {
+                return;
+            }
+            m_Initialized = true;
+            m_UnityTransport = (UnityTransport)target;
+
+            var connectionDataProperty = serializedObject.FindProperty(nameof(UnityTransport.ConnectionData));
+
+            m_ServerAddressProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.Address));
+            m_ServerPortProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.Port));
+            m_OverrideBindIpProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.ServerListenAddress));
+        }
+
+        /// <summary>
+        /// Draws inspector properties without the script field.
+        /// </summary>
+        public override void OnInspectorGUI()
+        {
+            Initialize();
+            EditorGUI.BeginChangeCheck();
+            serializedObject.UpdateIfRequiredOrScript();
+            DrawPropertiesExcluding(serializedObject, k_HiddenFields);
+            serializedObject.ApplyModifiedProperties();
+            EditorGUI.EndChangeCheck();
+
+            EditorGUILayout.PropertyField(m_ServerAddressProperty);
+            EditorGUILayout.PropertyField(m_ServerPortProperty);
+
+            serializedObject.ApplyModifiedProperties();
+
+            EditorGUILayout.HelpBox("It's recommended to leave remote connections disabled for local testing to avoid exposing ports on your device.", MessageType.Info);
+            bool allowRemoteConnections = m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv4 && m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv6 && !string.IsNullOrEmpty(m_UnityTransport.ConnectionData.ServerListenAddress);
+            allowRemoteConnections = EditorGUILayout.Toggle(new GUIContent("Allow Remote Connections?", $"Bind IP: {m_UnityTransport.ConnectionData.ServerListenAddress}"), allowRemoteConnections);
+
+            bool isIpV6 = m_UnityTransport.ConnectionData.IsIpv6;
+
+            if (!allowRemoteConnections)
+            {
+                if (m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv4 && m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv6)
+                {
+                    if (isIpV6)
+                    {
+                        m_UnityTransport.ConnectionData.ServerListenAddress = k_LoopbackIpv6;
+                    }
+                    else
+                    {
+                        m_UnityTransport.ConnectionData.ServerListenAddress = k_LoopbackIpv4;
+                    }
+                    EditorUtility.SetDirty(m_UnityTransport);
+                }
+            }
+
+            using (new EditorGUI.DisabledScope(!allowRemoteConnections))
+            {
+                string overrideIp = m_UnityTransport.ConnectionData.ServerListenAddress;
+                if (overrideIp == k_AnyIpv4 || overrideIp == k_AnyIpv6 || overrideIp == k_LoopbackIpv4 || overrideIp == k_LoopbackIpv6)
+                {
+                    overrideIp = "";
+                }
+
+                overrideIp = EditorGUILayout.TextField("Override Bind IP (optional)", overrideIp);
+                if (allowRemoteConnections)
+                {
+                    if (overrideIp == "")
+                    {
+                        if (isIpV6)
+                        {
+                            overrideIp = k_AnyIpv6;
+                        }
+                        else
+                        {
+                            overrideIp = k_AnyIpv4;
+                        }
+                    }
+
+                    if (m_UnityTransport.ConnectionData.ServerListenAddress != overrideIp)
+                    {
+                        m_UnityTransport.ConnectionData.ServerListenAddress = overrideIp;
+                        EditorUtility.SetDirty(m_UnityTransport);
+                    }
+                }
+            }
+        }
     }
 
 #if COM_UNITY_MODULES_ANIMATION

Editor/NetworkBehaviourEditor.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Reflection;
-using UnityEngine;
-using UnityEditor;
 using Unity.Netcode.Editor.Configuration;
+using UnityEditor;
+using UnityEngine;
 
 namespace Unity.Netcode.Editor
 {
@@ -20,6 +20,7 @@ namespace Unity.Netcode.Editor
         private readonly Dictionary<string, object> m_NetworkVariableObjects = new Dictionary<string, object>();
 
         private GUIContent m_NetworkVariableLabelGuiContent;
+        private GUIContent m_NetworkListLabelGuiContent;
 
         private void Init(MonoScript script)
         {
@@ -30,6 +31,7 @@ namespace Unity.Netcode.Editor
             m_NetworkVariableObjects.Clear();
 
             m_NetworkVariableLabelGuiContent = new GUIContent("NetworkVariable", "This variable is a NetworkVariable. It can not be serialized and can only be changed during runtime.");
+            m_NetworkListLabelGuiContent = new GUIContent("NetworkList", "This variable is a NetworkList. It is rendered, but you can't serialize or change it.");
 
             var fields = script.GetClass().GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
             for (int i = 0; i < fields.Length; i++)
@@ -39,6 +41,13 @@ namespace Unity.Netcode.Editor
                 {
                     m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name));
                     m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]);
+                    Debug.Log($"Adding NetworkVariable {fields[i].Name}");
+                }
+                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkList<>) && !fields[i].IsDefined(typeof(HideInInspector), true))
+                {
+                    m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name));
+                    m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]);
+                    Debug.Log($"Adding NetworkList {fields[i].Name}");
                 }
             }
         }
@@ -72,25 +81,48 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.BeginHorizontal();
             if (genericType.IsValueType)
             {
-                var method = typeof(NetworkBehaviourEditor).GetMethod("RenderNetworkVariableValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                var method = typeof(NetworkBehaviourEditor).GetMethod("RenderNetworkContainerValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
                 var genericMethod = method.MakeGenericMethod(genericType);
                 genericMethod.Invoke(this, new[] { (object)index });
             }
             else
             {
                 EditorGUILayout.LabelField("Type not renderable");
+
+                GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x));
+                EditorGUILayout.EndHorizontal();
+            }
+        }
+
+        private void RenderNetworkContainerValueType<T>(int index) where T : unmanaged, IEquatable<T>
+        {
+            try
+            {
+                var networkVariable = (NetworkVariable<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
+                RenderNetworkVariableValueType(index, networkVariable);
+            }
+            catch (Exception)
+            {
+                try
+                {
+                    var networkList = (NetworkList<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
+                    RenderNetworkListValueType(index, networkList);
+                }
+                catch (Exception e)
+                {
+                    Debug.Log(e);
+                    throw;
+                }
             }
 
-            GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x));
             EditorGUILayout.EndHorizontal();
         }
 
-        private void RenderNetworkVariableValueType<T>(int index) where T : unmanaged
+        private void RenderNetworkVariableValueType<T>(int index, NetworkVariable<T> networkVariable) where T : unmanaged
         {
-            var networkVariable = (NetworkVariable<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
             var type = typeof(T);
             object val = networkVariable.Value;
-            string name = m_NetworkVariableNames[index];
+            string variableName = m_NetworkVariableNames[index];
 
             var behaviour = (NetworkBehaviour)target;
 
@@ -99,47 +131,51 @@ namespace Unity.Netcode.Editor
             {
                 if (type == typeof(int))
                 {
-                    val = EditorGUILayout.IntField(name, (int)val);
+                    val = EditorGUILayout.IntField(variableName, (int)val);
                 }
                 else if (type == typeof(uint))
                 {
-                    val = (uint)EditorGUILayout.LongField(name, (long)((uint)val));
+                    val = (uint)EditorGUILayout.LongField(variableName, (uint)val);
                 }
                 else if (type == typeof(short))
                 {
-                    val = (short)EditorGUILayout.IntField(name, (int)((short)val));
+                    val = (short)EditorGUILayout.IntField(variableName, (short)val);
                 }
                 else if (type == typeof(ushort))
                 {
-                    val = (ushort)EditorGUILayout.IntField(name, (int)((ushort)val));
+                    val = (ushort)EditorGUILayout.IntField(variableName, (ushort)val);
                 }
                 else if (type == typeof(sbyte))
                 {
-                    val = (sbyte)EditorGUILayout.IntField(name, (int)((sbyte)val));
+                    val = (sbyte)EditorGUILayout.IntField(variableName, (sbyte)val);
                 }
                 else if (type == typeof(byte))
                 {
-                    val = (byte)EditorGUILayout.IntField(name, (int)((byte)val));
+                    val = (byte)EditorGUILayout.IntField(variableName, (byte)val);
                 }
                 else if (type == typeof(long))
                 {
-                    val = EditorGUILayout.LongField(name, (long)val);
+                    val = EditorGUILayout.LongField(variableName, (long)val);
                 }
                 else if (type == typeof(ulong))
                 {
-                    val = (ulong)EditorGUILayout.LongField(name, (long)((ulong)val));
+                    val = (ulong)EditorGUILayout.LongField(variableName, (long)((ulong)val));
+                }
+                else if (type == typeof(float))
+                {
+                    val = EditorGUILayout.FloatField(variableName, (float)((float)val));
                 }
                 else if (type == typeof(bool))
                 {
-                    val = EditorGUILayout.Toggle(name, (bool)val);
+                    val = EditorGUILayout.Toggle(variableName, (bool)val);
                 }
                 else if (type == typeof(string))
                 {
-                    val = EditorGUILayout.TextField(name, (string)val);
+                    val = EditorGUILayout.TextField(variableName, (string)val);
                 }
                 else if (type.IsEnum)
                 {
-                    val = EditorGUILayout.EnumPopup(name, (Enum)val);
+                    val = EditorGUILayout.EnumPopup(variableName, (Enum)val);
                 }
                 else
                 {
@@ -150,11 +186,31 @@ namespace Unity.Netcode.Editor
             }
             else
             {
-                EditorGUILayout.LabelField(name, EditorStyles.wordWrappedLabel);
+                EditorGUILayout.LabelField(variableName, EditorStyles.wordWrappedLabel);
                 EditorGUILayout.SelectableLabel(val.ToString(), EditorStyles.wordWrappedLabel);
             }
+            GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x));
         }
 
+        private void RenderNetworkListValueType<T>(int index, NetworkList<T> networkList)
+            where T : unmanaged, IEquatable<T>
+        {
+            string variableName = m_NetworkVariableNames[index];
+
+            string value = "";
+            bool addComma = false;
+            foreach (var v in networkList)
+            {
+                if (addComma)
+                {
+                    value += ", ";
+                }
+                value += v.ToString();
+                addComma = true;
+            }
+            EditorGUILayout.LabelField(variableName, value);
+            GUILayout.Label(m_NetworkListLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkListLabelGuiContent).x));
+        }
 
         /// <inheritdoc/>
         public override void OnInspectorGUI()
@@ -310,7 +366,7 @@ namespace Unity.Netcode.Editor
                     // and the user has already turned "Auto-Add NetworkObject" on when first notified about the requirement
                     // then just send a reminder to the user why the NetworkObject they just deleted seemingly "re-appeared"
                     // again.
-                    if (networkObjectRemoved && NetcodeForGameObjectsSettings.GetAutoAddNetworkObjectSetting())
+                    if (networkObjectRemoved && NetcodeForGameObjectsEditorSettings.GetAutoAddNetworkObjectSetting())
                     {
                         Debug.LogWarning($"{gameObject.name} still has {nameof(NetworkBehaviour)}s and Auto-Add NetworkObjects is enabled. A NetworkObject is being added back to {gameObject.name}.");
                         Debug.Log($"To reset Auto-Add NetworkObjects: Select the Netcode->General->Reset Auto-Add NetworkObject menu item.");
@@ -319,7 +375,7 @@ namespace Unity.Netcode.Editor
                     // Notify and provide the option to add it one time, always add a NetworkObject, or do nothing and let the user manually add it
                     if (EditorUtility.DisplayDialog($"{nameof(NetworkBehaviour)}s require a {nameof(NetworkObject)}",
                     $"{gameObject.name} does not have a {nameof(NetworkObject)} component.  Would you like to add one now?", "Yes", "No (manually add it)",
-                    DialogOptOutDecisionType.ForThisMachine, NetcodeForGameObjectsSettings.AutoAddNetworkObjectIfNoneExists))
+                    DialogOptOutDecisionType.ForThisMachine, NetcodeForGameObjectsEditorSettings.AutoAddNetworkObjectIfNoneExists))
                     {
                         gameObject.AddComponent<NetworkObject>();
                         var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();

Editor/NetworkManagerEditor.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
+using Unity.Netcode.Editor.Configuration;
 using UnityEditor;
 using UnityEngine;
-using UnityEditorInternal;
-using Unity.Netcode.Editor.Configuration;
 
 namespace Unity.Netcode.Editor
 {
@@ -40,8 +40,7 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_NetworkIdRecycleDelayProperty;
         private SerializedProperty m_RpcHashSizeProperty;
         private SerializedProperty m_LoadSceneTimeOutProperty;
-
+        private SerializedProperty m_PrefabsList;
-        private ReorderableList m_NetworkPrefabsList;
 
         private NetworkManager m_NetworkManager;
         private bool m_Initialized;
@@ -106,7 +105,9 @@ namespace Unity.Netcode.Editor
             m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay");
             m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
             m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
-
+            m_PrefabsList = m_NetworkConfigProperty
+                .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
+                .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
 
             ReloadTransports();
         }
@@ -132,76 +133,9 @@ namespace Unity.Netcode.Editor
             m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay");
             m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
             m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
-        }
+            m_PrefabsList = m_NetworkConfigProperty
-
+                .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
-        private void OnEnable()
+                .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
-        {
-            m_NetworkPrefabsList = new ReorderableList(serializedObject, serializedObject.FindProperty(nameof(NetworkManager.NetworkConfig)).FindPropertyRelative(nameof(NetworkConfig.NetworkPrefabs)), true, true, true, true);
-            m_NetworkPrefabsList.elementHeightCallback = index =>
-            {
-                var networkOverrideInt = 0;
-                if (m_NetworkPrefabsList.count > 0)
-                {
-                    var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
-                    var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
-                    networkOverrideInt = networkOverrideProp.enumValueIndex;
-                }
-
-                return 8 + (networkOverrideInt == 0 ? EditorGUIUtility.singleLineHeight : (EditorGUIUtility.singleLineHeight * 2) + 5);
-            };
-            m_NetworkPrefabsList.drawElementCallback = (rect, index, isActive, isFocused) =>
-            {
-                rect.y += 5;
-
-                var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
-                var networkPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Prefab));
-                var networkSourceHashProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourceHashToOverride));
-                var networkSourcePrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourcePrefabToOverride));
-                var networkTargetPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.OverridingTargetPrefab));
-                var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
-                var networkOverrideInt = networkOverrideProp.enumValueIndex;
-                var networkOverrideEnum = (NetworkPrefabOverride)networkOverrideInt;
-                EditorGUI.LabelField(new Rect(rect.x + rect.width - 70, rect.y, 60, EditorGUIUtility.singleLineHeight), "Override");
-                if (networkOverrideEnum == NetworkPrefabOverride.None)
-                {
-                    if (EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), false))
-                    {
-                        networkOverrideProp.enumValueIndex = (int)NetworkPrefabOverride.Prefab;
-                    }
-                }
-                else
-                {
-                    if (!EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), true))
-                    {
-                        networkOverrideProp.enumValueIndex = 0;
-                        networkOverrideEnum = NetworkPrefabOverride.None;
-                    }
-                }
-
-                if (networkOverrideEnum == NetworkPrefabOverride.None)
-                {
-                    EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width - 80, EditorGUIUtility.singleLineHeight), networkPrefabProp, GUIContent.none);
-                }
-                else
-                {
-                    networkOverrideProp.enumValueIndex = GUI.Toolbar(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), networkOverrideInt - 1, new[] { "Prefab", "Hash" }) + 1;
-
-                    if (networkOverrideEnum == NetworkPrefabOverride.Prefab)
-                    {
-                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourcePrefabProp, GUIContent.none);
-                    }
-                    else
-                    {
-                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourceHashProp, GUIContent.none);
-                    }
-
-                    rect.y += EditorGUIUtility.singleLineHeight + 5;
-
-                    EditorGUI.LabelField(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), "Overriding Prefab");
-                    EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 110, EditorGUIUtility.singleLineHeight), networkTargetPrefabProp, GUIContent.none);
-                }
-            };
-            m_NetworkPrefabsList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, "NetworkPrefabs");
         }
 
         /// <inheritdoc/>
@@ -224,7 +158,62 @@ namespace Unity.Netcode.Editor
                 EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
                 EditorGUILayout.Space();
 
-                m_NetworkPrefabsList.DoLayoutList();
+                if (m_NetworkManager.NetworkConfig.HasOldPrefabList())
+                {
+                    EditorGUILayout.HelpBox("Network Prefabs serialized in old format. Migrate to new format to edit the list.", MessageType.Info);
+                    if (GUILayout.Button(new GUIContent("Migrate Prefab List", "Converts the old format Network Prefab list to a new Scriptable Object")))
+                    {
+                        // Default directory
+                        var directory = "Assets/";
+                        var assetPath = AssetDatabase.GetAssetPath(m_NetworkManager);
+                        if (assetPath == "")
+                        {
+                            assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(m_NetworkManager);
+                        }
+
+                        if (assetPath != "")
+                        {
+                            directory = Path.GetDirectoryName(assetPath);
+                        }
+                        else
+                        {
+#if UNITY_2021_1_OR_NEWER
+                            var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
+#else
+                            var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
+#endif
+                            if (prefabStage != null)
+                            {
+                                var prefabPath = prefabStage.assetPath;
+                                if (!string.IsNullOrEmpty(prefabPath))
+                                {
+                                    directory = Path.GetDirectoryName(prefabPath);
+                                }
+                            }
+                            if (m_NetworkManager.gameObject.scene != null)
+                            {
+                                var scenePath = m_NetworkManager.gameObject.scene.path;
+                                if (!string.IsNullOrEmpty(scenePath))
+                                {
+                                    directory = Path.GetDirectoryName(scenePath);
+                                }
+                            }
+                        }
+                        var networkPrefabs = m_NetworkManager.NetworkConfig.MigrateOldNetworkPrefabsToNetworkPrefabsList();
+                        string path = Path.Combine(directory, $"NetworkPrefabs-{m_NetworkManager.GetInstanceID()}.asset");
+                        Debug.Log("Saving migrated Network Prefabs List to " + path);
+                        AssetDatabase.CreateAsset(networkPrefabs, path);
+                        EditorUtility.SetDirty(m_NetworkManager);
+                    }
+                }
+                else
+                {
+                    if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabsLists.Count == 0)
+                    {
+                        EditorGUILayout.HelpBox("You have no prefab list selected. You will have to add your prefabs manually at runtime for netcode to work.", MessageType.Warning);
+                    }
+                    EditorGUILayout.PropertyField(m_PrefabsList);
+                }
                 EditorGUILayout.Space();
 
                 EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
@@ -242,13 +231,7 @@ namespace Unity.Netcode.Editor
                     {
                         ReloadTransports();
 
-                        var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]);
+                        var transportComponent = m_NetworkManager.gameObject.GetComponent(m_TransportTypes[selection - 1]) ?? m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
-
-                        if (transportComponent == null)
-                        {
-                            transportComponent = m_NetworkManager.gameObject.AddComponent(m_TransportTypes[selection - 1]);
-                        }
-
                         m_NetworkTransportProperty.objectReferenceValue = transportComponent;
 
                         Repaint();
@@ -359,22 +342,26 @@ namespace Unity.Netcode.Editor
             const string targetUrl = "https://docs-multiplayer.unity3d.com/netcode/current/tools/install-tools";
             const string infoIconName = "console.infoicon";
 
-            if (NetcodeForGameObjectsSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
+            if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
             {
                 return;
             }
 
             if (s_CenteredWordWrappedLabelStyle == null)
             {
-                s_CenteredWordWrappedLabelStyle = new GUIStyle(GUI.skin.label);
+                s_CenteredWordWrappedLabelStyle = new GUIStyle(GUI.skin.label)
-                s_CenteredWordWrappedLabelStyle.wordWrap = true;
+                {
-                s_CenteredWordWrappedLabelStyle.alignment = TextAnchor.MiddleLeft;
+                    wordWrap = true,
+                    alignment = TextAnchor.MiddleLeft
+                };
             }
 
             if (s_HelpBoxStyle == null)
             {
-                s_HelpBoxStyle = new GUIStyle(EditorStyles.helpBox);
+                s_HelpBoxStyle = new GUIStyle(EditorStyles.helpBox)
-                s_HelpBoxStyle.padding = new RectOffset(10, 10, 10, 10);
+                {
+                    padding = new RectOffset(10, 10, 10, 10)
+                };
             }
 
             var openDocsButtonStyle = GUI.skin.button;
@@ -405,7 +392,7 @@ namespace Unity.Netcode.Editor
                 GUILayout.FlexibleSpace();
                 if (GUILayout.Button(dismissButtonText, dismissButtonStyle, GUILayout.ExpandWidth(false)))
                 {
-                    NetcodeForGameObjectsSettings.SetNetcodeInstallMultiplayerToolTips(1);
+                    NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(1);
                 }
                 EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
                 GUILayout.FlexibleSpace();

Editor/NetworkManagerHelper.cs

@@ -1,8 +1,9 @@
 using System.Collections.Generic;
 using System.Linq;
+using Unity.Netcode.Editor.Configuration;
+using UnityEditor;
 using UnityEngine;
 using UnityEngine.SceneManagement;
-using UnityEditor;
 
 namespace Unity.Netcode.Editor
 {
@@ -32,6 +33,24 @@ namespace Unity.Netcode.Editor
 
             EditorApplication.playModeStateChanged += EditorApplication_playModeStateChanged;
             EditorApplication.hierarchyChanged += EditorApplication_hierarchyChanged;
+
+            // Initialize default values for new NetworkManagers
+            //
+            // When the default prefab list is enabled, this will default
+            // new NetworkManagers to using it.
+            //
+            // This will get run when new NetworkManagers are added, and
+            // when the user presses the "reset" button on a NetworkManager
+            // in the inspector.
+            NetworkManager.OnNetworkManagerReset = manager =>
+            {
+                var settings = NetcodeForGameObjectsProjectSettings.instance;
+                if (settings.GenerateDefaultNetworkPrefabs)
+                {
+                    manager.NetworkConfig = new NetworkConfig();
+                    manager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out _, true) };
+                }
+            };
         }
 
         private static void EditorApplication_playModeStateChanged(PlayModeStateChange playModeStateChange)

Editor/NetworkObjectEditor.cs

@@ -1,6 +1,6 @@
 using System.Collections.Generic;
-using UnityEngine;
 using UnityEditor;
+using UnityEngine;
 
 namespace Unity.Netcode.Editor
 {

Editor/NetworkTransformEditor.cs

@@ -1,6 +1,6 @@
+using Unity.Netcode.Components;
 using UnityEditor;
 using UnityEngine;
-using Unity.Netcode.Components;
 
 namespace Unity.Netcode.Editor
 {
@@ -25,6 +25,11 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_InLocalSpaceProperty;
         private SerializedProperty m_InterpolateProperty;
 
+        private SerializedProperty m_UseQuaternionSynchronization;
+        private SerializedProperty m_UseQuaternionCompression;
+        private SerializedProperty m_UseHalfFloatPrecision;
+        private SerializedProperty m_SlerpPosition;
+
         private static int s_ToggleOffset = 45;
         private static float s_MaxRowWidth = EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth + 5;
         private static GUIContent s_PositionLabel = EditorGUIUtility.TrTextContent("Position");
@@ -48,6 +53,10 @@ namespace Unity.Netcode.Editor
             m_ScaleThresholdProperty = serializedObject.FindProperty(nameof(NetworkTransform.ScaleThreshold));
             m_InLocalSpaceProperty = serializedObject.FindProperty(nameof(NetworkTransform.InLocalSpace));
             m_InterpolateProperty = serializedObject.FindProperty(nameof(NetworkTransform.Interpolate));
+            m_UseQuaternionSynchronization = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionSynchronization));
+            m_UseQuaternionCompression = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionCompression));
+            m_UseHalfFloatPrecision = serializedObject.FindProperty(nameof(NetworkTransform.UseHalfFloatPrecision));
+            m_SlerpPosition = serializedObject.FindProperty(nameof(NetworkTransform.SlerpPosition));
         }
 
         /// <inheritdoc/>
@@ -71,6 +80,8 @@ namespace Unity.Netcode.Editor
 
                 GUILayout.EndHorizontal();
             }
+
+            if (!m_UseQuaternionSynchronization.boolValue)
             {
                 GUILayout.BeginHorizontal();
 
@@ -88,6 +99,13 @@ namespace Unity.Netcode.Editor
 
                 GUILayout.EndHorizontal();
             }
+            else
+            {
+                m_SyncRotationXProperty.boolValue = true;
+                m_SyncRotationYProperty.boolValue = true;
+                m_SyncRotationZProperty.boolValue = true;
+            }
+
             {
                 GUILayout.BeginHorizontal();
 
@@ -116,6 +134,17 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
             EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
             EditorGUILayout.PropertyField(m_InterpolateProperty);
+            EditorGUILayout.PropertyField(m_SlerpPosition);
+            EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);
+            if (m_UseQuaternionSynchronization.boolValue)
+            {
+                EditorGUILayout.PropertyField(m_UseQuaternionCompression);
+            }
+            else
+            {
+                m_UseQuaternionCompression.boolValue = false;
+            }
+            EditorGUILayout.PropertyField(m_UseHalfFloatPrecision);
 
 #if COM_UNITY_MODULES_PHYSICS
             // if rigidbody is present but network rigidbody is not present

Runtime/AssemblyInfo.cs

@@ -1,15 +1,25 @@
 using System.Runtime.CompilerServices;
-
+[assembly: InternalsVisibleTo("Unity.Netcode.Components")]
 #if UNITY_EDITOR
-[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
-[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
 [assembly: InternalsVisibleTo("Unity.Netcode.Editor")]
-[assembly: InternalsVisibleTo("TestProject.EditorTests")]
 [assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
-#endif
+#endif // UNITY_EDITOR
-[assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")]
+#if MULTIPLAYER_TOOLS
-[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
+[assembly: InternalsVisibleTo("Unity.Multiplayer.Tools.Adapters.Ngo1WithUtp2")]
+#endif // MULTIPLAYER_TOOLS
+#if COM_UNITY_NETCODE_ADAPTER_UTP
+[assembly: InternalsVisibleTo("Unity.Netcode.Adapter.UTP")]
+#endif // COM_UNITY_NETCODE_ADAPTER_UTP
+
+#if UNITY_INCLUDE_TESTS
 [assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")]
 [assembly: InternalsVisibleTo("Unity.Netcode.TestHelpers.Runtime")]
-[assembly: InternalsVisibleTo("Unity.Netcode.Adapter.UTP")]
+[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
-[assembly: InternalsVisibleTo("Unity.Multiplayer.Tools.Adapters.Ngo1WithUtp2")]
+#if UNITY_EDITOR
+[assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
+[assembly: InternalsVisibleTo("TestProject.EditorTests")]
+#endif // UNITY_EDITOR
+#if MULTIPLAYER_TOOLS
+[assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")]
+#endif // MULTIPLAYER_TOOLS
+#endif // UNITY_INCLUDE_TESTS

Runtime/Configuration/NetworkConfig.cs

@@ -1,8 +1,9 @@
 using System;
 using System.Collections.Generic;
-using UnityEngine;
 using System.Linq;
 using Unity.Collections;
+using UnityEngine;
+using UnityEngine.Serialization;
 
 namespace Unity.Netcode
 {
@@ -30,20 +31,8 @@ namespace Unity.Netcode
         [Tooltip("When set, NetworkManager will automatically create and spawn the assigned player prefab. This can be overridden by adding it to the NetworkPrefabs list and selecting override.")]
         public GameObject PlayerPrefab;
 
-        /// <summary>
-        /// A list of prefabs that can be dynamically spawned.
-        /// </summary>
         [SerializeField]
-        [Tooltip("The prefabs that can be spawned across the network")]
+        public NetworkPrefabs Prefabs = new NetworkPrefabs();
-        internal List<NetworkPrefab> NetworkPrefabs = new List<NetworkPrefab>();
-
-        /// <summary>
-        /// This dictionary provides a quick way to check and see if a NetworkPrefab has a NetworkPrefab override.
-        /// Generated at runtime and OnValidate
-        /// </summary>
-        internal Dictionary<uint, NetworkPrefab> NetworkPrefabOverrideLinks = new Dictionary<uint, NetworkPrefab>();
-
-        internal Dictionary<uint, uint> OverrideToNetworkPrefab = new Dictionary<uint, uint>();
 
 
         /// <summary>
@@ -219,6 +208,14 @@ namespace Unity.Netcode
 
         private ulong? m_ConfigHash = null;
 
+        /// <summary>
+        /// Clears out the configuration hash value generated for a specific network session
+        /// </summary>
+        internal void ClearConfigHash()
+        {
+            m_ConfigHash = null;
+        }
+
         /// <summary>
         /// Gets a SHA256 hash of parts of the NetworkConfig instance
         /// </summary>
@@ -239,7 +236,7 @@ namespace Unity.Netcode
 
                 if (ForceSamePrefabs)
                 {
-                    var sortedDictionary = NetworkPrefabOverrideLinks.OrderBy(x => x.Key);
+                    var sortedDictionary = Prefabs.NetworkPrefabOverrideLinks.OrderBy(x => x.Key);
                     foreach (var sortedEntry in sortedDictionary)
 
                     {
@@ -273,6 +270,75 @@ namespace Unity.Netcode
         {
             return hash == GetConfig();
         }
+
+        internal void InitializePrefabs()
+        {
+            if (HasOldPrefabList())
+            {
+                MigrateOldNetworkPrefabsToNetworkPrefabsList();
+            }
+
+            Prefabs.Initialize();
+        }
+
+        [NonSerialized]
+        private bool m_DidWarnOldPrefabList = false;
+
+        private void WarnOldPrefabList()
+        {
+            if (!m_DidWarnOldPrefabList)
+            {
+                Debug.LogWarning("Using Legacy Network Prefab List. Consider Migrating.");
+                m_DidWarnOldPrefabList = true;
+            }
+        }
+
+        /// <summary>
+        /// Returns true if the old List&lt;NetworkPrefab&gt; serialized data is present.
+        /// </summary>
+        /// <remarks>
+        /// Internal use only to help migrate projects. <seealso cref="MigrateOldNetworkPrefabsToNetworkPrefabsList"/></remarks>
+        internal bool HasOldPrefabList()
+        {
+            return OldPrefabList?.Count > 0;
+        }
+
+        /// <summary>
+        /// Migrate the old format List&lt;NetworkPrefab&gt; prefab registration to the new NetworkPrefabsList ScriptableObject.
+        /// </summary>
+        /// <remarks>
+        /// OnAfterDeserialize cannot instantiate new objects (e.g. NetworkPrefabsList SO) since it executes in a thread, so we have to do it later.
+        /// Since NetworkConfig isn't a Unity.Object it doesn't get an Awake callback, so we have to do this in NetworkManager and expose this API.
+        /// </remarks>
+        internal NetworkPrefabsList MigrateOldNetworkPrefabsToNetworkPrefabsList()
+        {
+            if (OldPrefabList == null || OldPrefabList.Count == 0)
+            {
+                return null;
+            }
+
+            if (Prefabs == null)
+            {
+                throw new Exception("Prefabs field is null.");
+            }
+
+            Prefabs.NetworkPrefabsLists.Add(ScriptableObject.CreateInstance<NetworkPrefabsList>());
+
+            if (OldPrefabList?.Count > 0)
+            {
+                // Migrate legacy types/fields
+                foreach (var networkPrefab in OldPrefabList)
+                {
+                    Prefabs.NetworkPrefabsLists[Prefabs.NetworkPrefabsLists.Count - 1].Add(networkPrefab);
+                }
+            }
+
+            OldPrefabList = null;
+            return Prefabs.NetworkPrefabsLists[Prefabs.NetworkPrefabsLists.Count - 1];
+        }
+
+        [FormerlySerializedAs("NetworkPrefabs")]
+        [SerializeField]
+        internal List<NetworkPrefab> OldPrefabList;
     }
 }
-

Runtime/Configuration/NetworkPrefab.cs

@@ -3,10 +3,23 @@ using UnityEngine;
 
 namespace Unity.Netcode
 {
-    internal enum NetworkPrefabOverride
+    /// <summary>
+    /// The method of NetworkPrefab override used to identify the source prefab
+    /// </summary>
+    public enum NetworkPrefabOverride
     {
+        /// <summary>
+        /// No oeverride is present
+        /// </summary>
         None,
+        /// <summary>
+        /// Override the prefab when the given SourcePrefabToOverride is requested
+        /// </summary>
         Prefab,
+        /// <summary>
+        /// Override the prefab when the given SourceHashToOverride is requested
+        /// Used in situations where the server assets do not exist in client builds
+        /// </summary>
         Hash
     }
 
@@ -14,10 +27,10 @@ namespace Unity.Netcode
     /// Class that represents a NetworkPrefab
     /// </summary>
     [Serializable]
-    internal class NetworkPrefab
+    public class NetworkPrefab
     {
         /// <summary>
-        /// The override setttings for this NetworkPrefab
+        /// The override settings for this NetworkPrefab
         /// </summary>
         public NetworkPrefabOverride Override;
 
@@ -41,5 +54,168 @@ namespace Unity.Netcode
         /// The prefab to replace (override) the source prefab with
         /// </summary>
         public GameObject OverridingTargetPrefab;
+
+        public bool Equals(NetworkPrefab other)
+        {
+            return Override == other.Override &&
+                   Prefab == other.Prefab &&
+                   SourcePrefabToOverride == other.SourcePrefabToOverride &&
+                   SourceHashToOverride == other.SourceHashToOverride &&
+                   OverridingTargetPrefab == other.OverridingTargetPrefab;
+        }
+
+        public uint SourcePrefabGlobalObjectIdHash
+        {
+            get
+            {
+                switch (Override)
+                {
+                    case NetworkPrefabOverride.None:
+                        if (Prefab != null && Prefab.TryGetComponent(out NetworkObject no))
+                        {
+                            return no.GlobalObjectIdHash;
+                        }
+
+                        throw new InvalidOperationException("Prefab field isn't set or isn't a Network Object");
+                    case NetworkPrefabOverride.Prefab:
+                        if (SourcePrefabToOverride != null && SourcePrefabToOverride.TryGetComponent(out no))
+                        {
+                            return no.GlobalObjectIdHash;
+                        }
+
+                        throw new InvalidOperationException("Source Prefab field isn't set or isn't a Network Object");
+                    case NetworkPrefabOverride.Hash:
+                        return SourceHashToOverride;
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+
+        public uint TargetPrefabGlobalObjectIdHash
+        {
+            get
+            {
+                switch (Override)
+                {
+                    case NetworkPrefabOverride.None:
+                        return 0;
+                    case NetworkPrefabOverride.Prefab:
+                    case NetworkPrefabOverride.Hash:
+                        if (OverridingTargetPrefab != null && OverridingTargetPrefab.TryGetComponent(out NetworkObject no))
+                        {
+                            return no.GlobalObjectIdHash;
+                        }
+
+                        throw new InvalidOperationException("Target Prefab field isn't set or isn't a Network Object");
+                    default:
+                        throw new ArgumentOutOfRangeException();
+                }
+            }
+        }
+
+        public bool Validate(int index = -1)
+        {
+            NetworkObject networkObject;
+            if (Override == NetworkPrefabOverride.None)
+            {
+                if (Prefab == null)
+                {
+                    NetworkLog.LogWarning($"{nameof(NetworkPrefab)} cannot be null ({nameof(NetworkPrefab)} at index: {index})");
+                    return false;
+                }
+
+                networkObject = Prefab.GetComponent<NetworkObject>();
+                if (networkObject == null)
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                    {
+                        NetworkLog.LogWarning($"{NetworkManager.PrefabDebugHelper(this)} is missing " +
+                                              $"a {nameof(NetworkObject)} component (entry will be ignored).");
+                    }
+                    return false;
+                }
+
+                return true;
+            }
+
+            // Validate source prefab override values first
+            switch (Override)
+            {
+                case NetworkPrefabOverride.Hash:
+                    {
+                        if (SourceHashToOverride == 0)
+                        {
+                            if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                            {
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourceHashToOverride)} is zero " +
+                                    "(entry will be ignored).");
+                            }
+                            return false;
+                        }
+
+                        break;
+                    }
+                case NetworkPrefabOverride.Prefab:
+                    {
+                        if (SourcePrefabToOverride == null)
+                        {
+                            // This is a leftover side-effect from NetworkManager's OnValidate. It's a usability
+                            // adjustment to automatically set the "Prefab" field as the source prefab when a user
+                            // swaps from the default Inspector to the override one.
+                            if (Prefab != null)
+                            {
+                                SourcePrefabToOverride = Prefab;
+                            }
+                            else if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                            {
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(SourcePrefabToOverride)} is null (entry will be ignored).");
+                                return false;
+                            }
+                        }
+
+                        if (!SourcePrefabToOverride.TryGetComponent(out networkObject))
+                        {
+                            if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                            {
+                                NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({SourcePrefabToOverride.name}) " +
+                                    $"is missing a {nameof(NetworkObject)} component (entry will be ignored).");
+                            }
+                            return false;
+                        }
+
+                        break;
+                    }
+            }
+
+            // Validate target prefab override values next
+            if (OverridingTargetPrefab == null)
+            {
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                {
+                    NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(OverridingTargetPrefab)} is null!");
+                }
+                switch (Override)
+                {
+                    case NetworkPrefabOverride.Hash:
+                        {
+                            Debug.LogWarning($"{nameof(NetworkPrefab)} override entry {SourceHashToOverride} will be removed and ignored.");
+                            break;
+                        }
+                    case NetworkPrefabOverride.Prefab:
+                        {
+                            Debug.LogWarning($"{nameof(NetworkPrefab)} override entry ({SourcePrefabToOverride.name}) will be removed and ignored.");
+                            break;
+                        }
+                }
+                return false;
+            }
+            return true;
+        }
+
+        public override string ToString()
+        {
+            return $"{{SourceHash: {SourceHashToOverride}, TargetHash: {TargetPrefabGlobalObjectIdHash}}}";
+        }
     }
 }

Runtime/Configuration/NetworkPrefabs.cs

@@ -0,0 +1,308 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// A class that represents the runtime aspect of network prefabs.
+    /// This class contains processed prefabs from the NetworkPrefabsList, as
+    /// well as additional modifications (additions and removals) made at runtime.
+    /// </summary>
+    [Serializable]
+    public class NetworkPrefabs
+    {
+        /// <summary>
+        /// Edit-time scripted object containing a list of NetworkPrefabs.
+        /// </summary>
+        /// <remarks>
+        /// This field can be null if no prefabs are pre-configured.
+        /// Runtime usages of <see cref="NetworkPrefabs"/> should not depend on this edit-time field for execution.
+        /// </remarks>
+        [SerializeField]
+        public List<NetworkPrefabsList> NetworkPrefabsLists = new List<NetworkPrefabsList>();
+
+        /// <summary>
+        /// This dictionary provides a quick way to check and see if a NetworkPrefab has a NetworkPrefab override.
+        /// Generated at runtime and OnValidate
+        /// </summary>
+        [NonSerialized]
+        public Dictionary<uint, NetworkPrefab> NetworkPrefabOverrideLinks = new Dictionary<uint, NetworkPrefab>();
+
+        [NonSerialized]
+        public Dictionary<uint, uint> OverrideToNetworkPrefab = new Dictionary<uint, uint>();
+
+        public IReadOnlyList<NetworkPrefab> Prefabs => m_Prefabs;
+
+        [NonSerialized]
+        private List<NetworkPrefab> m_Prefabs = new List<NetworkPrefab>();
+
+        private void AddTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
+        {
+            if (AddPrefabRegistration(networkPrefab))
+            {
+                m_Prefabs.Add(networkPrefab);
+            }
+        }
+
+        private void RemoveTriggeredByNetworkPrefabList(NetworkPrefab networkPrefab)
+        {
+            m_Prefabs.Remove(networkPrefab);
+        }
+
+        ~NetworkPrefabs()
+        {
+            Shutdown();
+        }
+
+        /// <summary>
+        /// Deregister from add and remove events
+        /// Clear the list
+        /// </summary>
+        internal void Shutdown()
+        {
+            foreach (var list in NetworkPrefabsLists)
+            {
+                list.OnAdd -= AddTriggeredByNetworkPrefabList;
+                list.OnRemove -= RemoveTriggeredByNetworkPrefabList;
+            }
+
+            NetworkPrefabsLists.Clear();
+        }
+
+        /// <summary>
+        /// Processes the <see cref="NetworkPrefabsList"/> if one is present for use during runtime execution,
+        /// else processes <see cref="Prefabs"/>.
+        /// </summary>
+        public void Initialize(bool warnInvalid = true)
+        {
+            if (NetworkPrefabsLists.Count != 0 && m_Prefabs.Count > 0)
+            {
+                NetworkLog.LogWarning("Runtime Network Prefabs was not empty at initialization time. Network " +
+                    "Prefab registrations made before initialization will be replaced by NetworkPrefabsList.");
+                m_Prefabs.Clear();
+            }
+
+            foreach (var list in NetworkPrefabsLists)
+            {
+                list.OnAdd += AddTriggeredByNetworkPrefabList;
+                list.OnRemove += RemoveTriggeredByNetworkPrefabList;
+            }
+
+            NetworkPrefabOverrideLinks.Clear();
+            OverrideToNetworkPrefab.Clear();
+
+            var prefabs = NetworkPrefabsLists.Count != 0 ? new List<NetworkPrefab>() : m_Prefabs;
+
+            if (NetworkPrefabsLists.Count != 0)
+            {
+                foreach (var list in NetworkPrefabsLists)
+                {
+                    foreach (var networkPrefab in list.PrefabList)
+                    {
+                        prefabs.Add(networkPrefab);
+                    }
+                }
+            }
+
+            m_Prefabs = new List<NetworkPrefab>();
+
+            List<NetworkPrefab> removeList = null;
+            if (warnInvalid)
+            {
+                removeList = new List<NetworkPrefab>();
+            }
+
+            foreach (var networkPrefab in prefabs)
+            {
+                if (AddPrefabRegistration(networkPrefab))
+                {
+                    m_Prefabs.Add(networkPrefab);
+                }
+                else
+                {
+                    removeList?.Add(networkPrefab);
+                }
+            }
+
+            // Clear out anything that is invalid or not used
+            if (removeList?.Count > 0)
+            {
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
+                {
+                    var sb = new StringBuilder("Removing invalid prefabs from Network Prefab registration: ");
+                    sb.Append(string.Join(", ", removeList));
+                    NetworkLog.LogWarning(sb.ToString());
+                }
+            }
+        }
+
+        /// <summary>
+        /// Add a new NetworkPrefab instance to the list
+        /// </summary>
+        /// <remarks>
+        /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually.
+        ///
+        /// Any modifications made here are not persisted. Permanent configuration changes should be done
+        /// through the <see cref="NetworkPrefabsList"/> scriptable object property.
+        /// </remarks>
+        public bool Add(NetworkPrefab networkPrefab)
+        {
+            if (AddPrefabRegistration(networkPrefab))
+            {
+                m_Prefabs.Add(networkPrefab);
+                return true;
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Remove a NetworkPrefab instance from the list
+        /// </summary>
+        /// <remarks>
+        /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually.
+        ///
+        /// Any modifications made here are not persisted. Permanent configuration changes should be done
+        /// through the <see cref="NetworkPrefabsList"/> scriptable object property.
+        /// </remarks>
+        public void Remove(NetworkPrefab prefab)
+        {
+            if (prefab == null)
+            {
+                throw new ArgumentNullException(nameof(prefab));
+            }
+
+            m_Prefabs.Remove(prefab);
+            OverrideToNetworkPrefab.Remove(prefab.TargetPrefabGlobalObjectIdHash);
+            NetworkPrefabOverrideLinks.Remove(prefab.SourcePrefabGlobalObjectIdHash);
+        }
+
+        /// <summary>
+        /// Remove a NetworkPrefab instance with matching <see cref="NetworkPrefab.Prefab"/> from the list
+        /// </summary>
+        /// <remarks>
+        /// The framework does not synchronize this list between clients. Any runtime changes must be handled manually.
+        ///
+        /// Any modifications made here are not persisted. Permanent configuration changes should be done
+        /// through the <see cref="NetworkPrefabsList"/> scriptable object property.
+        /// </remarks>
+        public void Remove(GameObject prefab)
+        {
+            if (prefab == null)
+            {
+                throw new ArgumentNullException(nameof(prefab));
+            }
+
+            for (int i = 0; i < m_Prefabs.Count; i++)
+            {
+                if (m_Prefabs[i].Prefab == prefab)
+                {
+                    Remove(m_Prefabs[i]);
+                    return;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Check if the given GameObject is present as a prefab within the list
+        /// </summary>
+        /// <param name="prefab">The prefab to check</param>
+        /// <returns>Whether or not the prefab exists</returns>
+        public bool Contains(GameObject prefab)
+        {
+            for (int i = 0; i < m_Prefabs.Count; i++)
+            {
+                if (m_Prefabs[i].Prefab == prefab)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Check if the given NetworkPrefab is present within the list
+        /// </summary>
+        /// <param name="prefab">The prefab to check</param>
+        /// <returns>Whether or not the prefab exists</returns>
+        public bool Contains(NetworkPrefab prefab)
+        {
+            for (int i = 0; i < m_Prefabs.Count; i++)
+            {
+                if (m_Prefabs[i].Equals(prefab))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Configures <see cref="NetworkPrefabOverrideLinks"/> and <see cref="OverrideToNetworkPrefab"/> for the given <see cref="NetworkPrefab"/>
+        /// </summary>
+        private bool AddPrefabRegistration(NetworkPrefab networkPrefab)
+        {
+            if (networkPrefab == null)
+            {
+                return false;
+            }
+            // Safeguard validation check since this method is called from outside of NetworkConfig and we can't control what's passed in.
+            if (!networkPrefab.Validate())
+            {
+                return false;
+            }
+
+            uint source = networkPrefab.SourcePrefabGlobalObjectIdHash;
+            uint target = networkPrefab.TargetPrefabGlobalObjectIdHash;
+
+            // Make sure the prefab isn't already registered.
+            if (NetworkPrefabOverrideLinks.ContainsKey(source))
+            {
+                var networkObject = networkPrefab.Prefab.GetComponent<NetworkObject>();
+
+                // This should never happen, but in the case it somehow does log an error and remove the duplicate entry
+                Debug.LogError($"{nameof(NetworkPrefab)} ({networkObject.name}) has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} source entry value of: {source}!");
+                return false;
+            }
+
+            // If we don't have an override configured, registration is simple!
+            if (networkPrefab.Override == NetworkPrefabOverride.None)
+            {
+                NetworkPrefabOverrideLinks.Add(source, networkPrefab);
+                return true;
+            }
+
+            // Make sure we don't have several overrides targeting the same prefab. Apparently we don't support that... shame.
+            if (OverrideToNetworkPrefab.ContainsKey(target))
+            {
+                var networkObject = networkPrefab.Prefab.GetComponent<NetworkObject>();
+
+                // This can happen if a user tries to make several GlobalObjectIdHash values point to the same target
+                Debug.LogError($"{nameof(NetworkPrefab)} (\"{networkObject.name}\") has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} target entry value of: {target}!");
+                return false;
+            }
+
+            switch (networkPrefab.Override)
+            {
+                case NetworkPrefabOverride.Prefab:
+                    {
+                        NetworkPrefabOverrideLinks.Add(source, networkPrefab);
+                        OverrideToNetworkPrefab.Add(target, source);
+                    }
+                    break;
+                case NetworkPrefabOverride.Hash:
+                    {
+                        NetworkPrefabOverrideLinks.Add(source, networkPrefab);
+                        OverrideToNetworkPrefab.Add(target, source);
+                    }
+                    break;
+            }
+
+            return true;
+        }
+    }
+}

Runtime/Configuration/NetworkPrefabs.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 230fc75f5639e46dc91734aa67d56a3e
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Configuration/NetworkPrefabsList.cs

@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// A ScriptableObject for holding a network prefabs list, which can be
+    /// shared between multiple NetworkManagers.
+    ///
+    /// When NetworkManagers hold references to this list, modifications to the
+    /// list at runtime will be picked up by all NetworkManagers that reference it.
+    /// </summary>
+    [CreateAssetMenu(fileName = "NetworkPrefabsList", menuName = "Netcode/Network Prefabs List")]
+    public class NetworkPrefabsList : ScriptableObject
+    {
+        internal delegate void OnAddDelegate(NetworkPrefab prefab);
+        internal OnAddDelegate OnAdd;
+
+        internal delegate void OnRemoveDelegate(NetworkPrefab prefab);
+        internal OnRemoveDelegate OnRemove;
+
+        [SerializeField]
+        internal bool IsDefault;
+
+        [FormerlySerializedAs("Prefabs")]
+        [SerializeField]
+        internal List<NetworkPrefab> List = new List<NetworkPrefab>();
+
+        /// <summary>
+        /// Read-only view into the prefabs list, enabling iterating and examining the list.
+        /// Actually modifying the list should be done using <see cref="Add"/>
+        /// and <see cref="Remove"/>.
+        /// </summary>
+        public IReadOnlyList<NetworkPrefab> PrefabList => List;
+
+        /// <summary>
+        /// Adds a prefab to the prefab list. Performing this here will apply the operation to all
+        /// <see cref="NetworkManager"/>s that reference this list.
+        /// </summary>
+        /// <param name="prefab"></param>
+        public void Add(NetworkPrefab prefab)
+        {
+            List.Add(prefab);
+            OnAdd?.Invoke(prefab);
+        }
+
+        /// <summary>
+        /// Removes a prefab from the prefab list. Performing this here will apply the operation to all
+        /// <see cref="NetworkManager"/>s that reference this list.
+        /// </summary>
+        /// <param name="prefab"></param>
+        public void Remove(NetworkPrefab prefab)
+        {
+            List.Remove(prefab);
+            OnRemove?.Invoke(prefab);
+        }
+
+        /// <summary>
+        /// Check if the given GameObject is present as a prefab within the list
+        /// </summary>
+        /// <param name="prefab">The prefab to check</param>
+        /// <returns>Whether or not the prefab exists</returns>
+        public bool Contains(GameObject prefab)
+        {
+            for (int i = 0; i < List.Count; i++)
+            {
+                if (List[i].Prefab == prefab)
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Check if the given NetworkPrefab is present within the list
+        /// </summary>
+        /// <param name="prefab">The prefab to check</param>
+        /// <returns>Whether or not the prefab exists</returns>
+        public bool Contains(NetworkPrefab prefab)
+        {
+            for (int i = 0; i < List.Count; i++)
+            {
+                if (List[i].Equals(prefab))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+    }
+}

Runtime/Configuration/NetworkPrefabsList.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e651dbb3fbac04af2b8f5abf007ddc23
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/Core/ComponentFactory.cs

@@ -52,6 +52,8 @@ namespace Unity.Netcode
         public static void SetDefaults()
         {
             SetDefault<IDeferredMessageManager>(networkManager => new DeferredMessageManager(networkManager));
+
+            SetDefault<IRealTimeProvider>(networkManager => new RealTimeProvider());
         }
 
         private static void SetDefault<T>(CreateObjectDelegate creator)

Runtime/Core/NetworkBehaviour.cs

@@ -1,9 +1,9 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using UnityEngine;
 using System.Reflection;
 using Unity.Collections;
+using UnityEngine;
 
 namespace Unity.Netcode
 {
@@ -82,7 +82,7 @@ namespace Unity.Netcode
                 var context = new NetworkContext
                 {
                     SenderId = NetworkManager.ServerClientId,
-                    Timestamp = Time.realtimeSinceStartup,
+                    Timestamp = NetworkManager.RealTimeProvider.RealTimeSinceStartup,
                     SystemOwner = NetworkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
@@ -219,7 +219,7 @@ namespace Unity.Netcode
                 var context = new NetworkContext
                 {
                     SenderId = NetworkManager.ServerClientId,
-                    Timestamp = Time.realtimeSinceStartup,
+                    Timestamp = NetworkManager.RealTimeProvider.RealTimeSinceStartup,
                     SystemOwner = NetworkManager,
                     // header information isn't valid since it's not a real message.
                     // RpcMessage doesn't access this stuff so it's just left empty.
@@ -314,18 +314,18 @@ namespace Unity.Netcode
         /// <summary>
         /// Gets if we are executing as server
         /// </summary>
-        protected bool IsServer { get; private set; }
+        public bool IsServer { get; private set; }
 
         /// <summary>
         /// Gets if we are executing as client
         /// </summary>
-        protected bool IsClient { get; private set; }
+        public bool IsClient { get; private set; }
 
 
         /// <summary>
         /// Gets if we are executing as Host, I.E Server and Client
         /// </summary>
-        protected bool IsHost { get; private set; }
+        public bool IsHost { get; private set; }
 
         /// <summary>
         /// Gets Whether or not the object has a owner
@@ -570,13 +570,10 @@ namespace Unity.Netcode
             if (list == null)
             {
                 list = new List<FieldInfo>();
-                list.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance));
-            }
-            else
-            {
-                list.AddRange(type.GetFields(BindingFlags.NonPublic | BindingFlags.Instance));
             }
 
+            list.AddRange(type.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.DeclaredOnly));
+
             if (type.BaseType != null && type.BaseType != typeof(NetworkBehaviour))
             {
                 return GetFieldInfoForTypeRecursive(type.BaseType, list);
@@ -600,13 +597,7 @@ namespace Unity.Netcode
                 var fieldType = sortedFields[i].FieldType;
                 if (fieldType.IsSubclassOf(typeof(NetworkVariableBase)))
                 {
-                    var instance = (NetworkVariableBase)sortedFields[i].GetValue(this);
+                    var instance = (NetworkVariableBase)sortedFields[i].GetValue(this) ?? throw new Exception($"{GetType().FullName}.{sortedFields[i].Name} cannot be null. All {nameof(NetworkVariableBase)} instances must be initialized.");
-
-                    if (instance == null)
-                    {
-                        throw new Exception($"{GetType().FullName}.{sortedFields[i].Name} cannot be null. All {nameof(NetworkVariableBase)} instances must be initialized.");
-                    }
-
                     instance.Initialize(this);
 
                     var instanceNameProperty = fieldType.GetProperty(nameof(NetworkVariableBase.Name));
@@ -899,11 +890,23 @@ namespace Unity.Netcode
         /// Either BufferSerializerReader or BufferSerializerWriter, depending whether the serializer
         /// is in read mode or write mode.
         /// </typeparam>
+        /// <param name="targetClientId">the relative client identifier being synchronized</param>
         protected virtual void OnSynchronize<T>(ref BufferSerializer<T> serializer) where T : IReaderWriter
         {
 
         }
 
+        /// <summary>
+        /// The relative client identifier targeted for the serialization of this <see cref="NetworkBehaviour"/> instance.
+        /// </summary>
+        /// <remarks>
+        /// This value will be set prior to <see cref="OnSynchronize{T}(ref BufferSerializer{T})"/> being invoked.
+        /// For writing (server-side), this is useful to know which client will receive the serialized data.
+        /// For reading (client-side), this will be the <see cref="NetworkManager.LocalClientId"/>.
+        /// When synchronization of this instance is complete, this value will be reset to 0
+        /// </remarks>
+        protected ulong m_TargetIdBeingSynchronized { get; private set; }
+
         /// <summary>
         /// Internal method that determines if a NetworkBehaviour has additional synchronization data to
         /// be synchronized when first instantiated prior to its associated NetworkObject being spawned.
@@ -913,8 +916,9 @@ namespace Unity.Netcode
         /// synchronize any remaining NetworkBehaviours.
         /// </remarks>
         /// <returns>true if it wrote synchronization data and false if it did not</returns>
-        internal bool Synchronize<T>(ref BufferSerializer<T> serializer) where T : IReaderWriter
+        internal bool Synchronize<T>(ref BufferSerializer<T> serializer, ulong targetClientId = 0) where T : IReaderWriter
         {
+            m_TargetIdBeingSynchronized = targetClientId;
             if (serializer.IsWriter)
             {
                 // Get the writer to handle seeking and determining how many bytes were written
@@ -949,6 +953,8 @@ namespace Unity.Netcode
                 }
                 var finalPosition = writer.Position;
 
+                // Reset before exiting
+                m_TargetIdBeingSynchronized = default;
                 // If we wrote nothing then skip writing anything for this NetworkBehaviour
                 if (finalPosition == positionBeforeSynchronize || threwException)
                 {
@@ -1002,6 +1008,9 @@ namespace Unity.Netcode
                     synchronizationError = true;
                 }
 
+                // Reset before exiting
+                m_TargetIdBeingSynchronized = default;
+
                 // Skip over the entry if deserialization fails
                 if (synchronizationError)
                 {

Runtime/Core/NetworkBehaviourUpdater.cs

@@ -72,6 +72,23 @@ namespace Unity.Netcode
                         }
                     }
                 }
+
+                foreach (var dirtyObj in m_DirtyNetworkObjects)
+                {
+                    for (int k = 0; k < dirtyObj.ChildNetworkBehaviours.Count; k++)
+                    {
+                        var behaviour = dirtyObj.ChildNetworkBehaviours[k];
+                        for (int i = 0; i < behaviour.NetworkVariableFields.Count; i++)
+                        {
+                            if (behaviour.NetworkVariableFields[i].IsDirty() &&
+                                !behaviour.NetworkVariableIndexesToResetSet.Contains(i))
+                            {
+                                behaviour.NetworkVariableIndexesToResetSet.Add(i);
+                                behaviour.NetworkVariableIndexesToReset.Add(i);
+                            }
+                        }
+                    }
+                }
                 // Now, reset all the no-longer-dirty variables
                 foreach (var dirtyobj in m_DirtyNetworkObjects)
                 {

Runtime/Core/NetworkManager.cs

@@ -67,6 +67,9 @@ namespace Unity.Netcode
 
         internal Dictionary<ulong, ConnectionApprovalResponse> ClientsToApprove = new Dictionary<ulong, ConnectionApprovalResponse>();
 
+        // Stores the objects that need to be shown at end-of-frame
+        internal Dictionary<ulong, List<NetworkObject>> ObjectsToShowToClient = new Dictionary<ulong, List<NetworkObject>>();
+
         /// <summary>
         /// The <see cref="NetworkPrefabHandler"/> instance created after starting the <see cref="NetworkManager"/>
         /// </summary>
@@ -140,15 +143,55 @@ namespace Unity.Netcode
 
             public bool OnVerifyCanReceive(ulong senderId, Type messageType, FastBufferReader messageContent, ref NetworkContext context)
             {
-                if (m_NetworkManager.PendingClients.TryGetValue(senderId, out PendingClient client) &&
+                if (m_NetworkManager.IsServer)
-                    (client.ConnectionState == PendingClient.State.PendingApproval || (client.ConnectionState == PendingClient.State.PendingConnection && messageType != typeof(ConnectionRequestMessage))))
                 {
-                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    if (messageType == typeof(ConnectionApprovedMessage))
                     {
-                        NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted");
+                        if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                        {
+                            NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from a client on the server side. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {MessagingSystem.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                        }
+                        return false;
+                    }
+                    if (m_NetworkManager.PendingClients.TryGetValue(senderId, out PendingClient client) &&
+                                     (client.ConnectionState == PendingClient.State.PendingApproval || (client.ConnectionState == PendingClient.State.PendingConnection && messageType != typeof(ConnectionRequestMessage))))
+                    {
+                        if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                        {
+                            NetworkLog.LogWarning($"Message received from {nameof(senderId)}={senderId} before it has been accepted");
+                        }
+
+                        return false;
                     }
 
-                    return false;
+                    if (m_NetworkManager.ConnectedClients.TryGetValue(senderId, out NetworkClient connectedClient) && messageType == typeof(ConnectionRequestMessage))
+                    {
+                        if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                        {
+                            NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from a client when the connection has already been established. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {MessagingSystem.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                        }
+
+                        return false;
+                    }
+                }
+                else
+                {
+                    if (messageType == typeof(ConnectionRequestMessage))
+                    {
+                        if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                        {
+                            NetworkLog.LogError($"A {nameof(ConnectionRequestMessage)} was received from the server on the client side. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {MessagingSystem.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                        }
+                        return false;
+                    }
+                    if (m_NetworkManager.IsConnectedClient && messageType == typeof(ConnectionApprovedMessage))
+                    {
+                        if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                        {
+                            NetworkLog.LogError($"A {nameof(ConnectionApprovedMessage)} was received from the server when the connection has already been established. This should not happen. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Message Size: {messageContent.Length}. Message Content: {MessagingSystem.ByteArrayToString(messageContent.ToArray(), 0, messageContent.Length)}");
+                        }
+                        return false;
+                    }
                 }
 
                 return !m_NetworkManager.m_StopProcessingMessages;
@@ -195,14 +238,14 @@ namespace Unity.Netcode
         {
             if (gameObject.TryGetComponent<NetworkObject>(out var networkObject))
             {
-                if (NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(networkObject.GlobalObjectIdHash))
+                if (NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(networkObject.GlobalObjectIdHash))
                 {
-                    switch (NetworkConfig.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].Override)
+                    switch (NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].Override)
                     {
                         case NetworkPrefabOverride.Hash:
                         case NetworkPrefabOverride.Prefab:
                             {
-                                return NetworkConfig.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].OverridingTargetPrefab;
+                                return NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[networkObject.GlobalObjectIdHash].OverridingTargetPrefab;
                             }
                     }
                 }
@@ -255,6 +298,8 @@ namespace Unity.Netcode
 
         internal IDeferredMessageManager DeferredMessageManager { get; private set; }
 
+        internal IRealTimeProvider RealTimeProvider { get; private set; }
+
         /// <summary>
         /// Gets the CustomMessagingManager for this NetworkManager
         /// </summary>
@@ -280,7 +325,7 @@ namespace Unity.Netcode
         /// </summary>
         public ulong LocalClientId
         {
-            get => IsServer ? NetworkConfig.NetworkTransport.ServerClientId : m_LocalClientId;
+            get => m_LocalClientId;
             internal set => m_LocalClientId = value;
         }
 
@@ -406,10 +451,28 @@ namespace Unity.Netcode
         public event Action<ulong> OnClientDisconnectCallback = null;
 
         /// <summary>
-        /// The callback to invoke once the server is ready
+        /// This callback is invoked when the local server is started and listening for incoming connections.
         /// </summary>
         public event Action OnServerStarted = null;
 
+        /// <summary>
+        /// The callback to invoke once the local client is ready
+        /// </summary>
+        public event Action OnClientStarted = null;
+
+        /// <summary>
+        /// This callback is invoked once the local server is stopped.
+        /// </summary>
+        /// <param name="arg1">The first parameter of this event will be set to <see cref="true"/> when stopping a host instance and <see cref="false"/> when stopping a server instance.</param>
+        public event Action<bool> OnServerStopped = null;
+
+        /// <summary>
+        /// The callback to invoke once the local client stops
+        /// </summary>
+        /// <remarks>The parameter states whether the client was running in host mode</remarks>
+        /// <param name="arg1">The first parameter of this event will be set to <see cref="true"/> when stopping the host client and <see cref="false"/> when stopping a standard client instance.</param>
+        public event Action<bool> OnClientStopped = null;
+
         /// <summary>
         /// The callback to invoke if the <see cref="NetworkTransport"/> fails.
         /// </summary>
@@ -508,6 +571,19 @@ namespace Unity.Netcode
 
         internal static event Action OnSingletonReady;
 
+#if UNITY_EDITOR
+        internal delegate void ResetNetworkManagerDelegate(NetworkManager manager);
+
+        internal static ResetNetworkManagerDelegate OnNetworkManagerReset;
+#endif
+
+        private void Reset()
+        {
+#if UNITY_EDITOR
+            OnNetworkManagerReset?.Invoke(this);
+#endif
+        }
+
 #if UNITY_EDITOR
         internal void OnValidate()
         {
@@ -533,72 +609,38 @@ namespace Unity.Netcode
             }
 
             // During OnValidate we will always clear out NetworkPrefabOverrideLinks and rebuild it
-            NetworkConfig.NetworkPrefabOverrideLinks.Clear();
+            NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.Clear();
 
+            var prefabs = NetworkConfig.Prefabs.Prefabs;
             // Check network prefabs and assign to dictionary for quick look up
-            for (int i = 0; i < NetworkConfig.NetworkPrefabs.Count; i++)
+            for (int i = 0; i < prefabs.Count; i++)
             {
-                var networkPrefab = NetworkConfig.NetworkPrefabs[i];
+                var networkPrefab = prefabs[i];
                 var networkPrefabGo = networkPrefab?.Prefab;
-                if (networkPrefabGo != null)
+                if (networkPrefabGo == null)
                 {
-                    if (!networkPrefabGo.TryGetComponent<NetworkObject>(out var networkObject))
+                    continue;
+                }
+
+                var networkObject = networkPrefabGo.GetComponent<NetworkObject>();
+                if (networkObject == null)
+                {
+                    if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                    {
+                        NetworkLog.LogError($"Cannot register {PrefabDebugHelper(networkPrefab)}, it does not have a {nameof(NetworkObject)} component at its root");
+                    }
+
+                    continue;
+                }
+
+                {
+                    var childNetworkObjects = new List<NetworkObject>();
+                    networkPrefabGo.GetComponentsInChildren(true, childNetworkObjects);
+                    if (childNetworkObjects.Count > 1) // total count = 1 root NetworkObject + n child NetworkObjects
                     {
                         if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
                         {
-                            NetworkLog.LogError($"Cannot register {PrefabDebugHelper(networkPrefab)}, it does not have a {nameof(NetworkObject)} component at its root");
+                            NetworkLog.LogWarning($"{PrefabDebugHelper(networkPrefab)} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)");
-                        }
-                    }
-                    else
-                    {
-                        {
-                            var childNetworkObjects = new List<NetworkObject>();
-                            networkPrefabGo.GetComponentsInChildren(true, childNetworkObjects);
-                            if (childNetworkObjects.Count > 1) // total count = 1 root NetworkObject + n child NetworkObjects
-                            {
-                                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
-                                {
-                                    NetworkLog.LogWarning($"{PrefabDebugHelper(networkPrefab)} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)");
-                                }
-                            }
-                        }
-
-                        // Default to the standard NetworkPrefab.Prefab's NetworkObject first
-                        var globalObjectIdHash = networkObject.GlobalObjectIdHash;
-
-                        // Now check to see if it has an override
-                        switch (networkPrefab.Override)
-                        {
-                            case NetworkPrefabOverride.Prefab:
-                                {
-                                    if (NetworkConfig.NetworkPrefabs[i].SourcePrefabToOverride == null &&
-                                        NetworkConfig.NetworkPrefabs[i].Prefab != null)
-                                    {
-                                        if (networkPrefab.SourcePrefabToOverride == null)
-                                        {
-                                            networkPrefab.SourcePrefabToOverride = networkPrefabGo;
-                                        }
-
-                                        globalObjectIdHash = networkPrefab.SourcePrefabToOverride.GetComponent<NetworkObject>().GlobalObjectIdHash;
-                                    }
-
-                                    break;
-                                }
-                            case NetworkPrefabOverride.Hash:
-                                globalObjectIdHash = networkPrefab.SourceHashToOverride;
-                                break;
-                        }
-
-                        // Add to the NetworkPrefabOverrideLinks or handle a new (blank) entries
-                        if (!NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash))
-                        {
-                            NetworkConfig.NetworkPrefabOverrideLinks.Add(globalObjectIdHash, networkPrefab);
-                        }
-                        else
-                        {
-                            // Duplicate entries can happen when adding a new entry into a list of existing entries
-                            // Either this is user error or a new entry, either case we replace it with a new, blank, NetworkPrefab under this condition
-                            NetworkConfig.NetworkPrefabs[i] = new NetworkPrefab();
                         }
                     }
                 }
@@ -640,22 +682,9 @@ namespace Unity.Netcode
             }
 
             var networkPrefab = new NetworkPrefab { Prefab = prefab };
-            NetworkConfig.NetworkPrefabs.Add(networkPrefab);
+            bool added = NetworkConfig.Prefabs.Add(networkPrefab);
-            if (IsListening)
+            if (IsListening && added)
             {
-                var sourcePrefabGlobalObjectIdHash = (uint)0;
-                var targetPrefabGlobalObjectIdHash = (uint)0;
-                if (!ShouldAddPrefab(networkPrefab, out sourcePrefabGlobalObjectIdHash, out targetPrefabGlobalObjectIdHash))
-                {
-                    NetworkConfig.NetworkPrefabs.Remove(networkPrefab);
-                    return;
-                }
-
-                if (!AddPrefabRegistration(networkPrefab, sourcePrefabGlobalObjectIdHash, targetPrefabGlobalObjectIdHash))
-                {
-                    NetworkConfig.NetworkPrefabs.Remove(networkPrefab);
-                    return;
-                }
                 DeferredMessageManager.ProcessTriggers(IDeferredMessageManager.TriggerType.OnAddPrefab, networkObject.GlobalObjectIdHash);
             }
         }
@@ -678,221 +707,14 @@ namespace Unity.Netcode
             }
 
             var globalObjectIdHash = prefab.GetComponent<NetworkObject>().GlobalObjectIdHash;
-            for (var i = 0; i < NetworkConfig.NetworkPrefabs.Count; ++i)
+            NetworkConfig.Prefabs.Remove(prefab);
-            {
-                if (NetworkConfig.NetworkPrefabs[i].Prefab.GetComponent<NetworkObject>().GlobalObjectIdHash == globalObjectIdHash)
-                {
-                    NetworkConfig.NetworkPrefabs.RemoveAt(i);
-                    break;
-                }
-            }
             if (PrefabHandler.ContainsHandler(globalObjectIdHash))
             {
                 PrefabHandler.RemoveHandler(globalObjectIdHash);
             }
-            if (NetworkConfig.NetworkPrefabOverrideLinks.TryGetValue(globalObjectIdHash, out var targetPrefab))
-            {
-                NetworkConfig.NetworkPrefabOverrideLinks.Remove(globalObjectIdHash);
-                var targetHash = targetPrefab.Prefab.GetComponent<NetworkObject>().GlobalObjectIdHash;
-                if (NetworkConfig.OverrideToNetworkPrefab.ContainsKey(targetHash))
-                {
-                    NetworkConfig.OverrideToNetworkPrefab.Remove(targetHash);
-                }
-            }
         }
 
-        private bool ShouldAddPrefab(NetworkPrefab networkPrefab, out uint sourcePrefabGlobalObjectIdHash, out uint targetPrefabGlobalObjectIdHash, int index = -1)
+        internal void Initialize(bool server)
-        {
-            sourcePrefabGlobalObjectIdHash = 0;
-            targetPrefabGlobalObjectIdHash = 0;
-            var networkObject = (NetworkObject)null;
-            if (networkPrefab == null || (networkPrefab.Prefab == null && networkPrefab.Override == NetworkPrefabOverride.None))
-            {
-                if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
-                {
-                    NetworkLog.LogWarning(
-                        $"{nameof(NetworkPrefab)} cannot be null ({nameof(NetworkPrefab)} at index: {index})");
-                }
-                return false;
-            }
-            else if (networkPrefab.Override == NetworkPrefabOverride.None)
-            {
-                if (!networkPrefab.Prefab.TryGetComponent(out networkObject))
-                {
-                    if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
-                    {
-                        NetworkLog.LogWarning($"{PrefabDebugHelper(networkPrefab)} is missing " +
-                                              $"a {nameof(NetworkObject)} component (entry will be ignored).");
-                    }
-                    return false;
-                }
-
-                // Otherwise get the GlobalObjectIdHash value
-                sourcePrefabGlobalObjectIdHash = networkObject.GlobalObjectIdHash;
-            }
-            else // Validate Overrides
-            {
-                // Validate source prefab override values first
-                switch (networkPrefab.Override)
-                {
-                    case NetworkPrefabOverride.Hash:
-                        {
-                            if (networkPrefab.SourceHashToOverride == 0)
-                            {
-                                if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
-                                {
-                                    NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(NetworkPrefab.SourceHashToOverride)} is zero " +
-                                                          "(entry will be ignored).");
-                                }
-                                return false;
-                            }
-                            sourcePrefabGlobalObjectIdHash = networkPrefab.SourceHashToOverride;
-                            break;
-                        }
-                    case NetworkPrefabOverride.Prefab:
-                        {
-                            if (networkPrefab.SourcePrefabToOverride == null)
-                            {
-                                if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
-                                {
-                                    NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(NetworkPrefab.SourcePrefabToOverride)} is null (entry will be ignored).");
-                                }
-
-                                Debug.LogWarning($"{nameof(NetworkPrefab)} override entry {networkPrefab.SourceHashToOverride} will be removed and ignored.");
-                                return false;
-                            }
-                            else
-                            {
-                                if (!networkPrefab.SourcePrefabToOverride.TryGetComponent(out networkObject))
-                                {
-                                    if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
-                                    {
-                                        NetworkLog.LogWarning($"{nameof(NetworkPrefab)} ({networkPrefab.SourcePrefabToOverride.name}) " +
-                                                              $"is missing a {nameof(NetworkObject)} component (entry will be ignored).");
-                                    }
-
-                                    Debug.LogWarning($"{nameof(NetworkPrefab)} override entry (\"{networkPrefab.SourcePrefabToOverride.name}\") will be removed and ignored.");
-                                    return false;
-                                }
-
-                                sourcePrefabGlobalObjectIdHash = networkObject.GlobalObjectIdHash;
-                            }
-                            break;
-                        }
-                }
-
-                // Validate target prefab override values next
-                if (networkPrefab.OverridingTargetPrefab == null)
-                {
-                    if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
-                    {
-                        NetworkLog.LogWarning($"{nameof(NetworkPrefab)} {nameof(NetworkPrefab.OverridingTargetPrefab)} is null!");
-                    }
-                    switch (networkPrefab.Override)
-                    {
-                        case NetworkPrefabOverride.Hash:
-                            {
-                                Debug.LogWarning($"{nameof(NetworkPrefab)} override entry {networkPrefab.SourceHashToOverride} will be removed and ignored.");
-                                break;
-                            }
-                        case NetworkPrefabOverride.Prefab:
-                            {
-                                Debug.LogWarning($"{nameof(NetworkPrefab)} override entry ({networkPrefab.SourcePrefabToOverride.name}) will be removed and ignored.");
-                                break;
-                            }
-                    }
-                    return false;
-                }
-                else
-                {
-                    targetPrefabGlobalObjectIdHash = networkPrefab.OverridingTargetPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash;
-                }
-            }
-            return true;
-        }
-
-        internal bool AddPrefabRegistration(NetworkPrefab networkPrefab, uint sourcePrefabGlobalObjectIdHash, uint targetPrefabGlobalObjectIdHash)
-        {
-            // Assign the appropriate GlobalObjectIdHash to the appropriate NetworkPrefab
-            if (!NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(sourcePrefabGlobalObjectIdHash))
-            {
-                if (networkPrefab.Override == NetworkPrefabOverride.None)
-                {
-                    NetworkConfig.NetworkPrefabOverrideLinks.Add(sourcePrefabGlobalObjectIdHash, networkPrefab);
-                }
-                else
-                {
-                    if (!NetworkConfig.OverrideToNetworkPrefab.ContainsKey(targetPrefabGlobalObjectIdHash))
-                    {
-                        switch (networkPrefab.Override)
-                        {
-                            case NetworkPrefabOverride.Prefab:
-                                {
-                                    NetworkConfig.NetworkPrefabOverrideLinks.Add(sourcePrefabGlobalObjectIdHash, networkPrefab);
-                                    NetworkConfig.OverrideToNetworkPrefab.Add(targetPrefabGlobalObjectIdHash, sourcePrefabGlobalObjectIdHash);
-                                }
-                                break;
-                            case NetworkPrefabOverride.Hash:
-                                {
-                                    NetworkConfig.NetworkPrefabOverrideLinks.Add(sourcePrefabGlobalObjectIdHash, networkPrefab);
-                                    NetworkConfig.OverrideToNetworkPrefab.Add(targetPrefabGlobalObjectIdHash, sourcePrefabGlobalObjectIdHash);
-                                }
-                                break;
-                        }
-                    }
-                    else
-                    {
-                        var networkObject = networkPrefab.Prefab.GetComponent<NetworkObject>();
-                        // This can happen if a user tries to make several GlobalObjectIdHash values point to the same target
-                        Debug.LogError($"{nameof(NetworkPrefab)} (\"{networkObject.name}\") has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} target entry value of: {targetPrefabGlobalObjectIdHash}! Removing entry from list!");
-                        return false;
-                    }
-                }
-            }
-            else
-            {
-                var networkObject = networkPrefab.Prefab.GetComponent<NetworkObject>();
-                // This should never happen, but in the case it somehow does log an error and remove the duplicate entry
-                Debug.LogError($"{nameof(NetworkPrefab)} ({networkObject.name}) has a duplicate {nameof(NetworkObject.GlobalObjectIdHash)} source entry value of: {sourcePrefabGlobalObjectIdHash}! Removing entry from list!");
-                return false;
-            }
-            return true;
-        }
-
-        private void InitializePrefabs(int startIdx = 0)
-        {
-            // This is used to remove entries not needed or invalid
-            var removeEmptyPrefabs = new List<int>();
-
-            // Build the NetworkPrefabOverrideLinks dictionary
-            for (int i = startIdx; i < NetworkConfig.NetworkPrefabs.Count; i++)
-            {
-                var sourcePrefabGlobalObjectIdHash = (uint)0;
-                var targetPrefabGlobalObjectIdHash = (uint)0;
-                if (!ShouldAddPrefab(NetworkConfig.NetworkPrefabs[i], out sourcePrefabGlobalObjectIdHash, out targetPrefabGlobalObjectIdHash, i))
-                {
-                    removeEmptyPrefabs.Add(i);
-                    continue;
-                }
-
-                if (!AddPrefabRegistration(NetworkConfig.NetworkPrefabs[i], sourcePrefabGlobalObjectIdHash, targetPrefabGlobalObjectIdHash))
-                {
-                    removeEmptyPrefabs.Add(i);
-                    continue;
-                }
-            }
-
-            // Clear out anything that is invalid or not used (for invalid entries we already logged warnings to the user earlier)
-            // Iterate backwards so indices don't shift as we remove
-            for (int i = removeEmptyPrefabs.Count - 1; i >= 0; i--)
-            {
-                NetworkConfig.NetworkPrefabs.RemoveAt(removeEmptyPrefabs[i]);
-            }
-
-            removeEmptyPrefabs.Clear();
-        }
-
-        private void Initialize(bool server)
         {
             // Don't allow the user to start a network session if the NetworkManager is
             // still parented under another GameObject
@@ -933,6 +755,8 @@ namespace Unity.Netcode
 
             DeferredMessageManager = ComponentFactory.Create<IDeferredMessageManager>(this);
 
+            RealTimeProvider = ComponentFactory.Create<IRealTimeProvider>(this);
+
             CustomMessagingManager = new CustomMessagingManager(this);
 
             SceneManager = new NetworkSceneManager(this);
@@ -982,11 +806,7 @@ namespace Unity.Netcode
 
             this.RegisterNetworkUpdate(NetworkUpdateStage.PreUpdate);
 
-            // Always clear our prefab override links before building
+            NetworkConfig.InitializePrefabs();
-            NetworkConfig.NetworkPrefabOverrideLinks.Clear();
-            NetworkConfig.OverrideToNetworkPrefab.Clear();
-
-            InitializePrefabs();
 
             // If we have a player prefab, then we need to verify it is in the list of NetworkPrefabOverrideLinks for client side spawning.
             if (NetworkConfig.PlayerPrefab != null)
@@ -994,15 +814,11 @@ namespace Unity.Netcode
                 if (NetworkConfig.PlayerPrefab.TryGetComponent<NetworkObject>(out var playerPrefabNetworkObject))
                 {
                     //In the event there is no NetworkPrefab entry (i.e. no override for default player prefab)
-                    if (!NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(playerPrefabNetworkObject
+                    if (!NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(playerPrefabNetworkObject
                         .GlobalObjectIdHash))
                     {
                         //Then add a new entry for the player prefab
-                        var playerNetworkPrefab = new NetworkPrefab();
+                        AddNetworkPrefab(NetworkConfig.PlayerPrefab);
-                        playerNetworkPrefab.Prefab = NetworkConfig.PlayerPrefab;
-                        NetworkConfig.NetworkPrefabs.Insert(0, playerNetworkPrefab);
-                        NetworkConfig.NetworkPrefabOverrideLinks.Add(playerPrefabNetworkObject.GlobalObjectIdHash,
-                            playerNetworkPrefab);
                     }
                 }
                 else
@@ -1048,6 +864,7 @@ namespace Unity.Netcode
             IsServer = true;
             IsClient = false;
             IsListening = true;
+            LocalClientId = ServerClientId;
 
             try
             {
@@ -1113,6 +930,7 @@ namespace Unity.Netcode
             IsClient = true;
             IsListening = true;
 
+            OnClientStarted?.Invoke();
             return true;
         }
 
@@ -1194,13 +1012,14 @@ namespace Unity.Netcode
 
             SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
 
+            OnServerStarted?.Invoke();
+            OnClientStarted?.Invoke();
+
             // This assures that any in-scene placed NetworkObject is spawned and
             // any associated NetworkBehaviours' netcode related properties are
             // set prior to invoking OnClientConnected.
             InvokeOnClientConnectedCallback(LocalClientId);
 
-            OnServerStarted?.Invoke();
-
             return true;
         }
 
@@ -1282,6 +1101,8 @@ namespace Unity.Netcode
 
         private void Awake()
         {
+            NetworkConfig?.InitializePrefabs();
+
             UnityEngine.SceneManagement.SceneManager.sceneUnloaded += OnSceneUnloaded;
         }
 
@@ -1311,13 +1132,13 @@ namespace Unity.Netcode
             return isParented;
         }
 
-        static internal string GenerateNestedNetworkManagerMessage(Transform transform)
+        internal static string GenerateNestedNetworkManagerMessage(Transform transform)
         {
             return $"{transform.name} is nested under {transform.root.name}. NetworkManager cannot be nested.\n";
         }
 
 #if UNITY_EDITOR
-        static internal INetworkManagerHelper NetworkManagerHelper;
+        internal static INetworkManagerHelper NetworkManagerHelper;
         /// <summary>
         /// Interface for NetworkManagerHelper
         /// </summary>
@@ -1398,13 +1219,12 @@ namespace Unity.Netcode
                 NetworkLog.LogInfo(nameof(ShutdownInternal));
             }
 
-            if (IsServer)
+            bool wasServer = IsServer;
+            bool wasClient = IsClient;
+            if (wasServer)
             {
                 // make sure all messages are flushed before transport disconnect clients
-                if (MessagingSystem != null)
+                MessagingSystem?.ProcessSendQueues();
-                {
-                    MessagingSystem.ProcessSendQueues();
-                }
 
                 var disconnectedIds = new HashSet<ulong>();
 
@@ -1440,10 +1260,22 @@ namespace Unity.Netcode
                 }
             }
 
+            // Unregister network updates before trying to disconnect the client
+            this.UnregisterAllNetworkUpdates();
+
             if (IsClient && IsListening)
             {
                 // Client only, send disconnect to server
-                NetworkConfig.NetworkTransport.DisconnectLocalClient();
+                // If transport throws and exception, log the exception and
+                // continue the shutdown sequence (or forever be shutting down)
+                try
+                {
+                    NetworkConfig.NetworkTransport.DisconnectLocalClient();
+                }
+                catch (Exception ex)
+                {
+                    Debug.LogException(ex);
+                }
             }
 
             IsConnectedClient = false;
@@ -1464,8 +1296,6 @@ namespace Unity.Netcode
             IsServer = false;
             IsClient = false;
 
-            this.UnregisterAllNetworkUpdates();
-
             if (NetworkTickSystem != null)
             {
                 NetworkTickSystem.Tick -= OnNetworkManagerTick;
@@ -1483,10 +1313,7 @@ namespace Unity.Netcode
                 NetworkConfig.NetworkTransport.OnTransportEvent -= HandleRawTransportPoll;
             }
 
-            if (DeferredMessageManager != null)
+            DeferredMessageManager?.CleanupAllTriggers();
-            {
-                DeferredMessageManager.CleanupAllTriggers();
-            }
 
             if (SceneManager != null)
             {
@@ -1521,6 +1348,22 @@ namespace Unity.Netcode
             m_StopProcessingMessages = false;
 
             ClearClients();
+
+            if (wasClient)
+            {
+                OnClientStopped?.Invoke(wasServer);
+            }
+            if (wasServer)
+            {
+                OnServerStopped?.Invoke(wasClient);
+            }
+
+            // This cleans up the internal prefabs list
+            NetworkConfig?.Prefabs.Shutdown();
+
+            // Reset the configuration hash for next session in the event
+            // that the prefab list changes
+            NetworkConfig?.ClearConfigHash();
         }
 
         /// <inheritdoc />
@@ -1620,7 +1463,7 @@ namespace Unity.Netcode
             }
 
             // Only update RTT here, server time is updated by time sync messages
-            var reset = NetworkTimeSystem.Advance(Time.unscaledDeltaTime);
+            var reset = NetworkTimeSystem.Advance(RealTimeProvider.UnscaledDeltaTime);
             if (reset)
             {
                 NetworkTickSystem.Reset(NetworkTimeSystem.LocalTime, NetworkTimeSystem.ServerTime);
@@ -1629,7 +1472,7 @@ namespace Unity.Netcode
 
             if (IsServer == false)
             {
-                NetworkTimeSystem.Sync(NetworkTimeSystem.LastSyncedServerTimeSec + Time.unscaledDeltaTime, NetworkConfig.NetworkTransport.GetCurrentRtt(ServerClientId) / 1000d);
+                NetworkTimeSystem.Sync(NetworkTimeSystem.LastSyncedServerTimeSec + RealTimeProvider.UnscaledDeltaTime, NetworkConfig.NetworkTransport.GetCurrentRtt(ServerClientId) / 1000d);
             }
         }
 
@@ -1638,6 +1481,10 @@ namespace Unity.Netcode
 
             if (!m_ShuttingDown || !m_StopProcessingMessages)
             {
+                // This should be invoked just prior to the MessagingSystem
+                // processes its outbound queue.
+                SceneManager.CheckForAndSendNetworkObjectSceneChanged();
+
                 MessagingSystem.ProcessSendQueues();
                 NetworkMetrics.UpdateNetworkObjectsCount(SpawnManager.SpawnedObjects.Count);
                 NetworkMetrics.UpdateConnectionsCount((IsServer) ? ConnectedClients.Count : 1);
@@ -1663,6 +1510,17 @@ namespace Unity.Netcode
             // Do NetworkVariable updates
             BehaviourUpdater.NetworkBehaviourUpdate(this);
 
+            // Handle NetworkObjects to show
+            foreach (var client in ObjectsToShowToClient)
+            {
+                ulong clientId = client.Key;
+                foreach (var networkObject in client.Value)
+                {
+                    SpawnManager.SendSpawnCallForObject(clientId, networkObject);
+                }
+            }
+            ObjectsToShowToClient.Clear();
+
             int timeSyncFrequencyTicks = (int)(k_TimeSyncFrequency * NetworkConfig.TickRate);
             if (IsServer && NetworkTickSystem.ServerTime.Tick % timeSyncFrequencyTicks == 0)
             {
@@ -1678,10 +1536,9 @@ namespace Unity.Netcode
                 // we should always force the rebuilding of the NetworkConfig hash value
                 ConfigHash = NetworkConfig.GetConfig(false),
                 ShouldSendConnectionData = NetworkConfig.ConnectionApproval,
-                ConnectionData = NetworkConfig.ConnectionData
+                ConnectionData = NetworkConfig.ConnectionData,
+                MessageVersions = new NativeArray<MessageVersionData>(MessagingSystem.MessageHandlers.Length, Allocator.Temp)
             };
-
-            message.MessageVersions = new NativeArray<MessageVersionData>(MessagingSystem.MessageHandlers.Length, Allocator.Temp);
             for (int index = 0; index < MessagingSystem.MessageHandlers.Length; index++)
             {
                 if (MessagingSystem.MessageTypes[index] != null)
@@ -1701,7 +1558,7 @@ namespace Unity.Netcode
 
         private IEnumerator ApprovalTimeout(ulong clientId)
         {
-            var timeStarted = IsServer ? LocalTime.TimeAsFloat : Time.realtimeSinceStartup;
+            var timeStarted = IsServer ? LocalTime.TimeAsFloat : RealTimeProvider.RealTimeSinceStartup;
             var timedOut = false;
             var connectionApproved = false;
             var connectionNotApproved = false;
@@ -1711,7 +1568,7 @@ namespace Unity.Netcode
             {
                 yield return null;
                 // Check if we timed out
-                timedOut = timeoutMarker < (IsServer ? LocalTime.TimeAsFloat : Time.realtimeSinceStartup);
+                timedOut = timeoutMarker < (IsServer ? LocalTime.TimeAsFloat : RealTimeProvider.RealTimeSinceStartup);
 
                 if (IsServer)
                 {
@@ -2053,8 +1910,10 @@ namespace Unity.Netcode
 
             if (!string.IsNullOrEmpty(reason))
             {
-                var disconnectReason = new DisconnectReasonMessage();
+                var disconnectReason = new DisconnectReasonMessage
-                disconnectReason.Reason = reason;
+                {
+                    Reason = reason
+                };
                 SendMessage(ref disconnectReason, NetworkDelivery.Reliable, clientId);
             }
             MessagingSystem.ProcessSendQueues();
@@ -2082,7 +1941,12 @@ namespace Unity.Netcode
                             }
                             else
                             {
-                                Destroy(playerObject.gameObject);
+                                // Call despawn to assure NetworkBehaviour.OnNetworkDespawn is invoked
+                                // on the server-side (when the client side disconnected).
+                                // This prevents the issue (when just destroying the GameObject) where
+                                // any NetworkBehaviour component(s) destroyed before the NetworkObject
+                                // would not have OnNetworkDespawn invoked.
+                                SpawnManager.DespawnObject(playerObject, true);
                             }
                         }
                         else
@@ -2198,15 +2062,19 @@ namespace Unity.Netcode
 
                 if (response.CreatePlayerObject)
                 {
-                    var playerPrefabHash = response.PlayerPrefabHash ?? NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>().GlobalObjectIdHash;
+                    var prefabNetworkObject = NetworkConfig.PlayerPrefab.GetComponent<NetworkObject>();
+                    var playerPrefabHash = response.PlayerPrefabHash ?? prefabNetworkObject.GlobalObjectIdHash;
 
                     // Generate a SceneObject for the player object to spawn
+                    // Note: This is only to create the local NetworkObject,
+                    // many of the serialized properties of the player prefab
+                    // will be set when instantiated.
                     var sceneObject = new NetworkObject.SceneObject
                     {
                         OwnerClientId = ownerClientId,
                         IsPlayerObject = true,
                         IsSceneObject = false,
-                        HasTransform = true,
+                        HasTransform = prefabNetworkObject.SynchronizeTransform,
                         Hash = playerPrefabHash,
                         TargetClientId = ownerClientId,
                         Transform = new NetworkObject.SceneObject.TransformData
@@ -2292,8 +2160,10 @@ namespace Unity.Netcode
             {
                 if (!string.IsNullOrEmpty(response.Reason))
                 {
-                    var disconnectReason = new DisconnectReasonMessage();
+                    var disconnectReason = new DisconnectReasonMessage
-                    disconnectReason.Reason = response.Reason;
+                    {
+                        Reason = response.Reason
+                    };
                     SendMessage(ref disconnectReason, NetworkDelivery.Reliable, ownerClientId);
 
                     MessagingSystem.ProcessSendQueues();
@@ -2334,5 +2204,37 @@ namespace Unity.Netcode
                 NetworkMetrics.TrackObjectSpawnSent(clientPair.Key, ConnectedClients[clientId].PlayerObject, size);
             }
         }
+
+        internal void MarkObjectForShowingTo(NetworkObject networkObject, ulong clientId)
+        {
+            if (!ObjectsToShowToClient.ContainsKey(clientId))
+            {
+                ObjectsToShowToClient.Add(clientId, new List<NetworkObject>());
+            }
+            ObjectsToShowToClient[clientId].Add(networkObject);
+        }
+
+        // returns whether any matching objects would have become visible and were returned to hidden state
+        internal bool RemoveObjectFromShowingTo(NetworkObject networkObject, ulong clientId)
+        {
+            var ret = false;
+            if (!ObjectsToShowToClient.ContainsKey(clientId))
+            {
+                return false;
+            }
+
+            // probably overkill, but deals with multiple entries
+            while (ObjectsToShowToClient[clientId].Contains(networkObject))
+            {
+                Debug.LogWarning(
+                    "Object was shown and hidden from the same client in the same Network frame. As a result, the client will _not_ receive a NetworkSpawn");
+                ObjectsToShowToClient[clientId].Remove(networkObject);
+                ret = true;
+            }
+
+            networkObject.Observers.Remove(clientId);
+
+            return ret;
+        }
     }
 }

Runtime/Core/NetworkObject.cs

@@ -17,6 +17,28 @@ namespace Unity.Netcode
         [SerializeField]
         internal uint GlobalObjectIdHash;
 
+        /// <summary>
+        /// Gets the Prefab Hash Id of this object if the object is registerd as a prefab otherwise it returns 0
+        /// </summary>
+        [HideInInspector]
+        public uint PrefabIdHash
+        {
+            get
+            {
+                foreach (var prefab in NetworkManager.NetworkConfig.Prefabs.Prefabs)
+                {
+                    if (prefab.Prefab == gameObject)
+                    {
+                        return GlobalObjectIdHash;
+                    }
+                }
+
+                return 0;
+            }
+        }
+
+        private bool m_IsPrefab;
+
 #if UNITY_EDITOR
         private void OnValidate()
         {
@@ -75,6 +97,18 @@ namespace Unity.Netcode
         /// </summary>
         public bool IsPlayerObject { get; internal set; }
 
+        /// <summary>
+        /// Determines if the associated NetworkObject's transform will get
+        /// synchronized when spawned.
+        /// </summary>
+        /// <remarks>
+        /// For things like in-scene placed NetworkObjects that have no visual
+        /// components can help reduce the instance's initial synchronization
+        /// bandwidth cost. This can also be useful for UI elements that have
+        /// a predetermined fixed position.
+        /// </remarks>
+        public bool SynchronizeTransform = true;
+
         /// <summary>
         /// Gets if the object is the personal clients player object
         /// </summary>
@@ -105,6 +139,55 @@ namespace Unity.Netcode
         /// </summary>
         public bool DestroyWithScene { get; set; }
 
+        /// <summary>
+        /// When set to true and the active scene is changed, this will automatically migrate the <see cref="NetworkObject"/>
+        /// into the new active scene on both the server and client instances.
+        /// </summary>
+        /// <remarks>
+        /// - This only applies to dynamically spawned <see cref="NetworkObject"/>s.
+        /// - This only works when using integrated scene management (<see cref="NetworkSceneManager"/>).
+        ///
+        /// If there are more than one scenes loaded and the currently active scene is unloaded, then typically
+        /// the <see cref="SceneManager"/> will automatically assign a new active scene. Similar to <see cref="DestroyWithScene"/>
+        /// being set to <see cref="false"/>, this prevents any <see cref="NetworkObject"/> from being destroyed
+        /// with the unloaded active scene by migrating it into the automatically assigned active scene.
+        /// Additionally, this is can be useful in some seamless scene streaming implementations.
+        /// Note:
+        /// Only having <see cref="ActiveSceneSynchronization"/> set to true will *not* synchronize clients when
+        /// changing a <see cref="NetworkObject"/>'s scene via <see cref="SceneManager.MoveGameObjectToScene(GameObject, Scene)"/>.
+        /// To synchronize clients of a <see cref="NetworkObject"/>'s scene being changed via <see cref="SceneManager.MoveGameObjectToScene(GameObject, Scene)"/>,
+        /// make sure <see cref="SceneMigrationSynchronization"/> is enabled (it is by default).
+        /// </remarks>
+        public bool ActiveSceneSynchronization;
+
+        /// <summary>
+        /// When enabled (the default), if a <see cref="NetworkObject"/> is migrated to a different scene (active or not)
+        /// via <see cref="SceneManager.MoveGameObjectToScene(GameObject, Scene)"/> on the server side all client
+        /// instances will be synchronized  and the <see cref="NetworkObject"/> migrated into the newly assigned scene.
+        /// The updated scene migration will get synchronized with late joining clients as well.
+        /// </summary>
+        /// <remarks>
+        /// - This only applies to dynamically spawned <see cref="NetworkObject"/>s.
+        /// - This only works when using integrated scene management (<see cref="NetworkSceneManager"/>).
+        /// Note:
+        /// You can have both <see cref="ActiveSceneSynchronization"/> and <see cref="SceneMigrationSynchronization"/> enabled.
+        /// The primary difference between the two is that <see cref="SceneMigrationSynchronization"/> only synchronizes clients
+        /// when the server migrates a <see cref="NetworkObject"/> to a new scene. If the scene is unloaded and <see cref="DestroyWithScene"/>
+        /// is <see cref="true"/> and <see cref="ActiveSceneSynchronization"/> is <see cref="false"/> and the scene is not the currently
+        /// active scene, then the <see cref="NetworkObject"/> will be destroyed.
+        /// </remarks>
+        public bool SceneMigrationSynchronization = true;
+
+        /// <summary>
+        /// Notifies when the NetworkObject is migrated into a new scene
+        /// </summary>
+        /// <remarks>
+        /// - <see cref="ActiveSceneSynchronization"/> or <see cref="SceneMigrationSynchronization"/> (or both) need to be enabled
+        /// - This only applies to dynamically spawned <see cref="NetworkObject"/>s.
+        /// - This only works when using integrated scene management (<see cref="NetworkSceneManager"/>).
+        /// </remarks>
+        public Action OnMigratedToNewScene;
+
         /// <summary>
         /// Delegate type for checking visibility
         /// </summary>
@@ -188,6 +271,11 @@ namespace Unity.Netcode
         /// </summary>
         internal int SceneOriginHandle = 0;
 
+        /// <summary>
+        /// The server-side scene origin handle
+        /// </summary>
+        internal int NetworkSceneHandle = 0;
+
         private Scene m_SceneOrigin;
         /// <summary>
         /// The scene where the NetworkObject was first instantiated
@@ -265,9 +353,17 @@ namespace Unity.Netcode
                 throw new VisibilityChangeException("The object is already visible");
             }
 
-            Observers.Add(clientId);
+            if (CheckObjectVisibility != null && !CheckObjectVisibility(clientId))
+            {
+                if (NetworkManager.LogLevel <= LogLevel.Normal)
+                {
+                    NetworkLog.LogWarning($"[NetworkShow] Trying to make {nameof(NetworkObject)} {gameObject.name} visible to client ({clientId}) but {nameof(CheckObjectVisibility)} returned false!");
+                }
+                return;
+            }
 
-            NetworkManager.SpawnManager.SendSpawnCallForObject(clientId, this);
+            NetworkManager.MarkObjectForShowingTo(this, clientId);
+            Observers.Add(clientId);
         }
 
 
@@ -351,26 +447,28 @@ namespace Unity.Netcode
                 throw new NotServerException("Only server can change visibility");
             }
 
-            if (!Observers.Contains(clientId))
-            {
-                throw new VisibilityChangeException("The object is already hidden");
-            }
-
             if (clientId == NetworkManager.ServerClientId)
             {
                 throw new VisibilityChangeException("Cannot hide an object from the server");
             }
 
-            Observers.Remove(clientId);
+            if (!NetworkManager.RemoveObjectFromShowingTo(this, clientId))
-
-            var message = new DestroyObjectMessage
             {
-                NetworkObjectId = NetworkObjectId,
+                if (!Observers.Contains(clientId))
-                DestroyGameObject = !IsSceneObject.Value
+                {
-            };
+                    throw new VisibilityChangeException("The object is already hidden");
-            // Send destroy call
+                }
-            var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
+                Observers.Remove(clientId);
-            NetworkManager.NetworkMetrics.TrackObjectDestroySent(clientId, this, size);
+
+                var message = new DestroyObjectMessage
+                {
+                    NetworkObjectId = NetworkObjectId,
+                    DestroyGameObject = !IsSceneObject.Value
+                };
+                // Send destroy call
+                var size = NetworkManager.SendMessage(ref message, NetworkDelivery.ReliableSequenced, clientId);
+                NetworkManager.NetworkMetrics.TrackObjectDestroySent(clientId, this, size);
+            }
         }
 
         /// <summary>
@@ -577,6 +675,22 @@ namespace Unity.Netcode
         private Transform m_CachedParent; // What is our last set parent Transform reference?
         private bool m_CachedWorldPositionStays = true; // Used to preserve the world position stays parameter passed in TrySetParent
 
+        /// <summary>
+        /// Returns the last known cached WorldPositionStays value for this NetworkObject
+        /// </summary>
+        /// <remarks>
+        /// When parenting NetworkObjects, the optional WorldPositionStays value is cached and synchronized with clients.
+        /// This method provides access to the instance relative cached value.
+        /// <see cref="TrySetParent(GameObject, bool)"/>
+        /// <see cref="TrySetParent(NetworkObject, bool)"/>
+        /// <see cref="TrySetParent(Transform, bool)"/>
+        /// </remarks>
+        /// <returns><see cref="true"/> or <see cref="false"/></returns>
+        public bool WorldPositionStays()
+        {
+            return m_CachedWorldPositionStays;
+        }
+
         internal void SetCachedParent(Transform parentTransform)
         {
             m_CachedParent = parentTransform;
@@ -1117,6 +1231,18 @@ namespace Unity.Netcode
                 set => ByteUtility.SetBit(ref m_BitField, 5, value);
             }
 
+            /// <summary>
+            /// Even though the server sends notifications for NetworkObjects that get
+            /// destroyed when a scene is unloaded, we want to synchronize this so
+            /// the client side can use it as part of a filter for automatically migrating
+            /// to the current active scene when its scene is unloaded. (only for dynamically spawned)
+            /// </summary>
+            public bool DestroyWithScene
+            {
+                get => ByteUtility.GetBit(m_BitField, 6);
+                set => ByteUtility.SetBit(ref m_BitField, 6, value);
+            }
+
             //If(Metadata.HasParent)
             public ulong ParentObjectId;
 
@@ -1159,7 +1285,7 @@ namespace Unity.Netcode
 
                 var writeSize = 0;
                 writeSize += HasTransform ? FastBufferWriter.GetWriteSize<TransformData>() : 0;
-                writeSize += IsSceneObject ? FastBufferWriter.GetWriteSize<int>() : 0;
+                writeSize += FastBufferWriter.GetWriteSize<int>();
 
                 if (!writer.TryBeginWrite(writeSize))
                 {
@@ -1171,14 +1297,9 @@ namespace Unity.Netcode
                     writer.WriteValue(Transform);
                 }
 
-                // In-Scene NetworkObjects are uniquely identified NetworkPrefabs defined by their
+                // The NetworkSceneHandle is the server-side relative
-                // NetworkSceneHandle and GlobalObjectIdHash. Client-side NetworkSceneManagers use
+                // scene handle that the NetworkObject resides in.
-                // this to locate their local instance of the in-scene placed NetworkObject instance.
+                writer.WriteValue(OwnerObject.GetSceneOriginHandle());
-                // Only written for in-scene placed NetworkObjects.
-                if (IsSceneObject)
-                {
-                    writer.WriteValue(OwnerObject.GetSceneOriginHandle());
-                }
 
                 // Synchronize NetworkVariables and NetworkBehaviours
                 var bufferSerializer = new BufferSerializer<BufferSerializerWriter>(new BufferSerializerWriter(writer));
@@ -1204,7 +1325,7 @@ namespace Unity.Netcode
 
                 var readSize = 0;
                 readSize += HasTransform ? FastBufferWriter.GetWriteSize<TransformData>() : 0;
-                readSize += IsSceneObject ? FastBufferWriter.GetWriteSize<int>() : 0;
+                readSize += FastBufferWriter.GetWriteSize<int>();
 
                 // Try to begin reading the remaining bytes
                 if (!reader.TryBeginRead(readSize))
@@ -1217,14 +1338,9 @@ namespace Unity.Netcode
                     reader.ReadValue(out Transform);
                 }
 
-                // In-Scene NetworkObjects are uniquely identified NetworkPrefabs defined by their
+                // The NetworkSceneHandle is the server-side relative
-                // NetworkSceneHandle and GlobalObjectIdHash. Client-side NetworkSceneManagers use
+                // scene handle that the NetworkObject resides in.
-                // this to locate their local instance of the in-scene placed NetworkObject instance.
+                reader.ReadValue(out NetworkSceneHandle);
-                // Only read for in-scene placed NetworkObjects
-                if (IsSceneObject)
-                {
-                    reader.ReadValue(out NetworkSceneHandle);
-                }
             }
         }
 
@@ -1264,7 +1380,7 @@ namespace Unity.Netcode
                 var synchronizationCount = (byte)0;
                 foreach (var childBehaviour in ChildNetworkBehaviours)
                 {
-                    if (childBehaviour.Synchronize(ref serializer))
+                    if (childBehaviour.Synchronize(ref serializer, targetClientId))
                     {
                         synchronizationCount++;
                     }
@@ -1303,7 +1419,7 @@ namespace Unity.Netcode
                 {
                     serializer.SerializeValue(ref networkBehaviourId);
                     var networkBehaviour = GetNetworkBehaviourAtOrderIndex(networkBehaviourId);
-                    networkBehaviour.Synchronize(ref serializer);
+                    networkBehaviour.Synchronize(ref serializer, targetClientId);
                 }
             }
         }
@@ -1316,6 +1432,7 @@ namespace Unity.Netcode
                 OwnerClientId = OwnerClientId,
                 IsPlayerObject = IsPlayerObject,
                 IsSceneObject = IsSceneObject ?? true,
+                DestroyWithScene = DestroyWithScene,
                 Hash = HostCheckForGlobalObjectIdHashOverride(),
                 OwnerObject = this,
                 TargetClientId = targetClientId
@@ -1351,7 +1468,7 @@ namespace Unity.Netcode
 
             if (IncludeTransformWhenSpawning == null || IncludeTransformWhenSpawning(OwnerClientId))
             {
-                obj.HasTransform = true;
+                obj.HasTransform = SynchronizeTransform;
 
                 // We start with the default AutoObjectParentSync values to determine which transform space we will
                 // be synchronizing clients with.
@@ -1434,11 +1551,126 @@ namespace Unity.Netcode
             networkObject.SynchronizeNetworkBehaviours(ref bufferSerializer, networkManager.LocalClientId);
 
             // Spawn the NetworkObject
-            networkManager.SpawnManager.SpawnNetworkObjectLocally(networkObject, sceneObject, false);
+            networkManager.SpawnManager.SpawnNetworkObjectLocally(networkObject, sceneObject, sceneObject.DestroyWithScene);
 
             return networkObject;
         }
 
+        /// <summary>
+        /// Subscribes to changes in the currently active scene
+        /// </summary>
+        /// <remarks>
+        /// Only for dynamically spawned NetworkObjects
+        /// </remarks>
+        internal void SubscribeToActiveSceneForSynch()
+        {
+            if (ActiveSceneSynchronization)
+            {
+                if (IsSceneObject.HasValue && !IsSceneObject.Value)
+                {
+                    // Just in case it is a recycled NetworkObject, unsubscribe first
+                    SceneManager.activeSceneChanged -= CurrentlyActiveSceneChanged;
+                    SceneManager.activeSceneChanged += CurrentlyActiveSceneChanged;
+                }
+            }
+        }
+
+        /// <summary>
+        /// If AutoSynchActiveScene is enabled, then this is the callback that handles updating
+        /// a NetworkObject's scene information.
+        /// </summary>
+        private void CurrentlyActiveSceneChanged(Scene current, Scene next)
+        {
+            // Early exit if there is no NetworkManager assigned, the NetworkManager is shutting down, the NetworkObject
+            // is not spawned, or an in-scene placed NetworkObject
+            if (NetworkManager == null || NetworkManager.ShutdownInProgress || !IsSpawned || IsSceneObject != false)
+            {
+                return;
+            }
+            // This check is here in the event a user wants to disable this for some reason but also wants
+            // the NetworkObject to synchronize to changes in the currently active scene at some later time.
+            if (ActiveSceneSynchronization)
+            {
+                // Only dynamically spawned NetworkObjects that are not already in the newly assigned active scene will migrate
+                // and update their scene handles
+                if (IsSceneObject.HasValue && !IsSceneObject.Value && gameObject.scene != next && gameObject.transform.parent == null)
+                {
+                    SceneManager.MoveGameObjectToScene(gameObject, next);
+                    SceneChangedUpdate(next);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Handles updating the NetworkObject's tracked scene handles
+        /// </summary>
+        internal void SceneChangedUpdate(Scene scene, bool notify = false)
+        {
+            // Avoiding edge case scenarios, if no NetworkSceneManager exit early
+            if (NetworkManager.SceneManager == null)
+            {
+                return;
+            }
+
+            SceneOriginHandle = scene.handle;
+            // Clients need to update the NetworkSceneHandle
+            if (!NetworkManager.IsServer && NetworkManager.SceneManager.ClientSceneHandleToServerSceneHandle.ContainsKey(SceneOriginHandle))
+            {
+                NetworkSceneHandle = NetworkManager.SceneManager.ClientSceneHandleToServerSceneHandle[SceneOriginHandle];
+            }
+            else if (NetworkManager.IsServer)
+            {
+                // Since the server is the source of truth for the NetworkSceneHandle,
+                // the NetworkSceneHandle is the same as the SceneOriginHandle.
+                NetworkSceneHandle = SceneOriginHandle;
+            }
+            else // Otherwise, the client did not find the client to server scene handle
+            if (NetworkManager.LogLevel == LogLevel.Developer)
+            {
+                // There could be a scenario where a user has some client-local scene loaded that they migrate the NetworkObject
+                // into, but that scenario seemed very edge case and under most instances a user should be notified that this
+                // server - client scene handle mismatch has occurred. It also seemed pertinent to make the message replicate to
+                // the server-side too.
+                NetworkLog.LogWarningServer($"[Client-{NetworkManager.LocalClientId}][{gameObject.name}] Server - " +
+                    $"client scene mismatch detected! Client-side scene handle ({SceneOriginHandle}) for scene ({gameObject.scene.name})" +
+                    $"has no associated server side (network) scene handle!");
+            }
+            OnMigratedToNewScene?.Invoke();
+
+            // Only the server side will notify clients of non-parented NetworkObject scene changes
+            if (NetworkManager.IsServer && notify && transform.parent == null)
+            {
+                NetworkManager.SceneManager.NotifyNetworkObjectSceneChanged(this);
+            }
+        }
+
+        /// <summary>
+        /// Update
+        /// Detects if a NetworkObject's scene has changed for both server and client instances
+        /// </summary>
+        /// <remarks>
+        /// About In-Scene Placed NetworkObjects:
+        /// Since the same scene can be loaded more than once and in-scene placed NetworkObjects GlobalObjectIdHash
+        /// values are only unique to the scene asset itself (and not per scene instance loaded), we will not be able
+        /// to add this same functionality to in-scene placed NetworkObjects until we have a way to generate
+        /// per-NetworkObject-instance unique GlobalObjectIdHash values for in-scene placed NetworkObjects.
+        /// </remarks>
+        private void Update()
+        {
+            // Early exit if SceneMigrationSynchronization is disabled, there is no NetworkManager assigned,
+            // the NetworkManager is shutting down, the NetworkObject is not spawned, it is an in-scene placed
+            // NetworkObject, or the GameObject's current scene handle is the same as the SceneOriginHandle
+            if (!SceneMigrationSynchronization || NetworkManager == null || NetworkManager.ShutdownInProgress || !IsSpawned
+                || IsSceneObject != false || gameObject.scene.handle == SceneOriginHandle)
+            {
+                return;
+            }
+
+            // Otherwise, this has to be a dynamically spawned NetworkObject that has been
+            // migrated to a new scene.
+            SceneChangedUpdate(gameObject.scene, true);
+        }
+
         /// <summary>
         /// Only applies to Host mode.
         /// Will return the registered source NetworkPrefab's GlobalObjectIdHash if one exists.
@@ -1454,9 +1686,9 @@ namespace Unity.Netcode
                     var globalObjectIdHash = NetworkManager.PrefabHandler.GetSourceGlobalObjectIdHash(GlobalObjectIdHash);
                     return globalObjectIdHash == 0 ? GlobalObjectIdHash : globalObjectIdHash;
                 }
-                else if (NetworkManager.NetworkConfig.OverrideToNetworkPrefab.ContainsKey(GlobalObjectIdHash))
+                if (NetworkManager.NetworkConfig.Prefabs.OverrideToNetworkPrefab.TryGetValue(GlobalObjectIdHash, out uint hash))
                 {
-                    return NetworkManager.NetworkConfig.OverrideToNetworkPrefab[GlobalObjectIdHash];
+                    return hash;
                 }
             }
 

Runtime/Core/NetworkUpdateLoop.cs

@@ -167,7 +167,7 @@ namespace Unity.Netcode
         /// </summary>
         public static NetworkUpdateStage UpdateStage;
 
-        private static void RunNetworkUpdateStage(NetworkUpdateStage updateStage)
+        internal static void RunNetworkUpdateStage(NetworkUpdateStage updateStage)
         {
             UpdateStage = updateStage;
 

Runtime/Hashing/XXHash.cs

@@ -1,6 +1,6 @@
 using System;
-using System.Text;
 using System.Runtime.CompilerServices;
+using System.Text;
 
 namespace Unity.Netcode
 {

Runtime/Messaging/BatchHeader.cs

@@ -5,9 +5,26 @@ namespace Unity.Netcode
     /// </summary>
     internal struct BatchHeader : INetworkSerializeByMemcpy
     {
+        internal const ushort MagicValue = 0x1160;
+        /// <summary>
+        /// A magic number to detect corrupt messages.
+        /// Always set to k_MagicValue
+        /// </summary>
+        public ushort Magic;
+
+        /// <summary>
+        /// Total number of bytes in the batch.
+        /// </summary>
+        public int BatchSize;
+
+        /// <summary>
+        /// Hash of the message to detect corrupt messages.
+        /// </summary>
+        public ulong BatchHash;
+
         /// <summary>
         /// Total number of messages in the batch.
         /// </summary>
-        public ushort BatchSize;
+        public ushort BatchCount;
     }
 }

Runtime/Messaging/CustomMessageManager.cs

@@ -151,14 +151,18 @@ namespace Unity.Netcode
                 // We dont know what size to use. Try every (more collision prone)
                 if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32))
                 {
+                    // handler can remove itself, cache the name for metrics
+                    string messageName = m_MessageHandlerNameLookup32[hash];
                     messageHandler32(sender, reader);
-                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup32[hash], bytesCount);
+                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                 }
 
                 if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64))
                 {
+                    // handler can remove itself, cache the name for metrics
+                    string messageName = m_MessageHandlerNameLookup64[hash];
                     messageHandler64(sender, reader);
-                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup64[hash], bytesCount);
+                    m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                 }
             }
             else
@@ -169,15 +173,19 @@ namespace Unity.Netcode
                     case HashSize.VarIntFourBytes:
                         if (m_NamedMessageHandlers32.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler32))
                         {
+                            // handler can remove itself, cache the name for metrics
+                            string messageName = m_MessageHandlerNameLookup32[hash];
                             messageHandler32(sender, reader);
-                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup32[hash], bytesCount);
+                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                         }
                         break;
                     case HashSize.VarIntEightBytes:
                         if (m_NamedMessageHandlers64.TryGetValue(hash, out HandleNamedMessageDelegate messageHandler64))
                         {
+                            // handler can remove itself, cache the name for metrics
+                            string messageName = m_MessageHandlerNameLookup64[hash];
                             messageHandler64(sender, reader);
-                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, m_MessageHandlerNameLookup64[hash], bytesCount);
+                            m_NetworkManager.NetworkMetrics.TrackNamedMessageReceived(sender, messageName, bytesCount);
                         }
                         break;
                 }

Runtime/Messaging/DeferredMessageManager.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using Unity.Collections;
-using Time = UnityEngine.Time;
 
 namespace Unity.Netcode
 {
@@ -49,7 +48,7 @@ namespace Unity.Netcode
             {
                 triggerInfo = new TriggerInfo
                 {
-                    Expiry = Time.realtimeSinceStartup + m_NetworkManager.NetworkConfig.SpawnTimeout,
+                    Expiry = m_NetworkManager.RealTimeProvider.RealTimeSinceStartup + m_NetworkManager.NetworkConfig.SpawnTimeout,
                     TriggerData = new NativeList<TriggerData>(Allocator.Persistent)
                 };
                 triggers[key] = triggerInfo;
@@ -77,7 +76,7 @@ namespace Unity.Netcode
                 int index = 0;
                 foreach (var kvp2 in kvp.Value)
                 {
-                    if (kvp2.Value.Expiry < Time.realtimeSinceStartup)
+                    if (kvp2.Value.Expiry < m_NetworkManager.RealTimeProvider.RealTimeSinceStartup)
                     {
                         staleKeys[index++] = kvp2.Key;
                         PurgeTrigger(kvp.Key, kvp2.Key, kvp2.Value);

Runtime/Messaging/DisconnectReasonMessage.cs

@@ -8,11 +8,7 @@ namespace Unity.Netcode
 
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
-            string reasonSent = Reason;
+            string reasonSent = Reason ?? string.Empty;
-            if (reasonSent == null)
-            {
-                reasonSent = string.Empty;
-            }
 
             // Since we don't send a ConnectionApprovedMessage, the version for this message is encded with the message
             // itself. However, note that we HAVE received a ConnectionRequestMessage, so we DO have a valid targetVersion

Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -64,6 +64,16 @@ namespace Unity.Netcode
                     shouldWrite = false;
                 }
 
+                // The object containing the behaviour we're about to process is about to be shown to this client
+                // As a result, the client will get the fully serialized NetworkVariable and would be confused by
+                // an extraneous delta
+                if (NetworkBehaviour.NetworkManager.ObjectsToShowToClient.ContainsKey(TargetClientId) &&
+                    NetworkBehaviour.NetworkManager.ObjectsToShowToClient[TargetClientId]
+                    .Contains(NetworkBehaviour.NetworkObject))
+                {
+                    shouldWrite = false;
+                }
+
                 if (NetworkBehaviour.NetworkManager.NetworkConfig.EnsureNetworkVariableLengthSafety)
                 {
                     if (!shouldWrite)
@@ -96,12 +106,6 @@ namespace Unity.Netcode
                         networkVariable.WriteDelta(writer);
                     }
 
-                    if (!NetworkBehaviour.NetworkVariableIndexesToResetSet.Contains(i))
-                    {
-                        NetworkBehaviour.NetworkVariableIndexesToResetSet.Add(i);
-                        NetworkBehaviour.NetworkVariableIndexesToReset.Add(i);
-                    }
-
                     NetworkBehaviour.NetworkManager.NetworkMetrics.TrackNetworkVariableDeltaSent(
                         TargetClientId,
                         NetworkBehaviour.NetworkObject,

Runtime/Messaging/Messages/RpcMessages.cs

@@ -1,6 +1,6 @@
 using System;
-using UnityEngine;
 using Unity.Collections;
+using UnityEngine;
 
 namespace Unity.Netcode
 {

Runtime/Messaging/MessagingSystem.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Runtime.CompilerServices;
+using System.Text;
 using Unity.Collections;
 using Unity.Collections.LowLevel.Unsafe;
 using UnityEngine;
@@ -41,7 +42,7 @@ namespace Unity.Netcode
             {
                 Writer = new FastBufferWriter(writerSize, writerAllocator, maxWriterSize);
                 NetworkDelivery = delivery;
-                BatchHeader = default;
+                BatchHeader = new BatchHeader { Magic = BatchHeader.MagicValue };
             }
         }
 
@@ -204,6 +205,17 @@ namespace Unity.Netcode
             return m_LocalVersions[messageType];
         }
 
+        internal static string ByteArrayToString(byte[] ba, int offset, int count)
+        {
+            var hex = new StringBuilder(ba.Length * 2);
+            for (int i = offset; i < offset + count; ++i)
+            {
+                hex.AppendFormat("{0:x2} ", ba[i]);
+            }
+
+            return hex.ToString();
+        }
+
         internal void HandleIncomingData(ulong clientId, ArraySegment<byte> data, float receiveTime)
         {
             unsafe
@@ -214,18 +226,38 @@ namespace Unity.Netcode
                         new FastBufferReader(nativeData + data.Offset, Allocator.None, data.Count);
                     if (!batchReader.TryBeginRead(sizeof(BatchHeader)))
                     {
-                        NetworkLog.LogWarning("Received a packet too small to contain a BatchHeader. Ignoring it.");
+                        NetworkLog.LogError("Received a packet too small to contain a BatchHeader. Ignoring it.");
                         return;
                     }
 
                     batchReader.ReadValue(out BatchHeader batchHeader);
 
-                    for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
+                    if (batchHeader.Magic != BatchHeader.MagicValue)
                     {
-                        m_Hooks[hookIdx].OnBeforeReceiveBatch(clientId, batchHeader.BatchSize, batchReader.Length);
+                        NetworkLog.LogError($"Received a packet with an invalid Magic Value. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Offset: {data.Offset}, Size: {data.Count}, Full receive array: {ByteArrayToString(data.Array, 0, data.Array.Length)}");
+                        return;
                     }
 
-                    for (var messageIdx = 0; messageIdx < batchHeader.BatchSize; ++messageIdx)
+                    if (batchHeader.BatchSize != data.Count)
+                    {
+                        NetworkLog.LogError($"Received a packet with an invalid Batch Size Value. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Offset: {data.Offset}, Size: {data.Count}, Expected Size: {batchHeader.BatchSize}, Full receive array: {ByteArrayToString(data.Array, 0, data.Array.Length)}");
+                        return;
+                    }
+
+                    var hash = XXHash.Hash64(batchReader.GetUnsafePtrAtCurrentPosition(), batchReader.Length - batchReader.Position);
+
+                    if (hash != batchHeader.BatchHash)
+                    {
+                        NetworkLog.LogError($"Received a packet with an invalid Hash Value. Please report this to the Netcode for GameObjects team at https://github.com/Unity-Technologies/com.unity.netcode.gameobjects/issues and include the following data: Received Hash: {batchHeader.BatchHash}, Calculated Hash: {hash}, Offset: {data.Offset}, Size: {data.Count}, Full receive array: {ByteArrayToString(data.Array, 0, data.Array.Length)}");
+                        return;
+                    }
+
+                    for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
+                    {
+                        m_Hooks[hookIdx].OnBeforeReceiveBatch(clientId, batchHeader.BatchCount, batchReader.Length);
+                    }
+
+                    for (var messageIdx = 0; messageIdx < batchHeader.BatchCount; ++messageIdx)
                     {
 
                         var messageHeader = new MessageHeader();
@@ -237,7 +269,7 @@ namespace Unity.Netcode
                         }
                         catch (OverflowException)
                         {
-                            NetworkLog.LogWarning("Received a batch that didn't have enough data for all of its batches, ending early!");
+                            NetworkLog.LogError("Received a batch that didn't have enough data for all of its batches, ending early!");
                             throw;
                         }
 
@@ -245,7 +277,7 @@ namespace Unity.Netcode
 
                         if (!batchReader.TryBeginRead((int)messageHeader.MessageSize))
                         {
-                            NetworkLog.LogWarning("Received a message that claimed a size larger than the packet, ending early!");
+                            NetworkLog.LogError("Received a message that claimed a size larger than the packet, ending early!");
                             return;
                         }
                         m_IncomingMessageQueue.Add(new ReceiveQueueItem
@@ -263,7 +295,7 @@ namespace Unity.Netcode
                     }
                     for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                     {
-                        m_Hooks[hookIdx].OnAfterReceiveBatch(clientId, batchHeader.BatchSize, batchReader.Length);
+                        m_Hooks[hookIdx].OnAfterReceiveBatch(clientId, batchHeader.BatchCount, batchReader.Length);
                     }
                 }
             }
@@ -333,37 +365,35 @@ namespace Unity.Netcode
 
         public void HandleMessage(in MessageHeader header, FastBufferReader reader, ulong senderId, float timestamp, int serializedHeaderSize)
         {
-            if (header.MessageType >= m_HighMessageType)
-            {
-                Debug.LogWarning($"Received a message with invalid message type value {header.MessageType}");
-                reader.Dispose();
-                return;
-            }
-            var context = new NetworkContext
-            {
-                SystemOwner = m_Owner,
-                SenderId = senderId,
-                Timestamp = timestamp,
-                Header = header,
-                SerializedHeaderSize = serializedHeaderSize,
-                MessageSize = header.MessageSize,
-            };
-
-            var type = m_ReverseTypeMap[header.MessageType];
-            if (!CanReceive(senderId, type, reader, ref context))
-            {
-                reader.Dispose();
-                return;
-            }
-
-            for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
-            {
-                m_Hooks[hookIdx].OnBeforeReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<MessageHeader>());
-            }
-
-            var handler = m_MessageHandlers[header.MessageType];
             using (reader)
             {
+                if (header.MessageType >= m_HighMessageType)
+                {
+                    Debug.LogWarning($"Received a message with invalid message type value {header.MessageType}");
+                    return;
+                }
+                var context = new NetworkContext
+                {
+                    SystemOwner = m_Owner,
+                    SenderId = senderId,
+                    Timestamp = timestamp,
+                    Header = header,
+                    SerializedHeaderSize = serializedHeaderSize,
+                    MessageSize = header.MessageSize,
+                };
+
+                var type = m_ReverseTypeMap[header.MessageType];
+                if (!CanReceive(senderId, type, reader, ref context))
+                {
+                    return;
+                }
+
+                var handler = m_MessageHandlers[header.MessageType];
+                for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
+                {
+                    m_Hooks[hookIdx].OnBeforeReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<MessageHeader>());
+                }
+
                 // This will also log an exception is if the server knows about a message type the client doesn't know
                 // about. In this case the handler will be null. It is still an issue the user must deal with: If the
                 // two connecting builds know about different messages, the server should not send a message to a client
@@ -388,10 +418,10 @@ namespace Unity.Netcode
                         Debug.LogException(e);
                     }
                 }
-            }
+                for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
-            for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
+                {
-            {
+                    m_Hooks[hookIdx].OnAfterReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<MessageHeader>());
-                m_Hooks[hookIdx].OnAfterReceiveMessage(senderId, type, reader.Length + FastBufferWriter.GetWriteSize<MessageHeader>());
+                }
             }
         }
 
@@ -650,7 +680,7 @@ namespace Unity.Netcode
 
                 writeQueueItem.Writer.WriteBytes(headerSerializer.GetUnsafePtr(), headerSerializer.Length);
                 writeQueueItem.Writer.WriteBytes(tmpSerializer.GetUnsafePtr(), tmpSerializer.Length);
-                writeQueueItem.BatchHeader.BatchSize++;
+                writeQueueItem.BatchHeader.BatchCount++;
                 for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                 {
                     m_Hooks[hookIdx].OnAfterSendMessage(clientId, ref message, delivery, tmpSerializer.Length + headerSerializer.Length);
@@ -745,7 +775,7 @@ namespace Unity.Netcode
                 for (var i = 0; i < sendQueueItem.Length; ++i)
                 {
                     ref var queueItem = ref sendQueueItem.ElementAt(i);
-                    if (queueItem.BatchHeader.BatchSize == 0)
+                    if (queueItem.BatchHeader.BatchCount == 0)
                     {
                         queueItem.Writer.Dispose();
                         continue;
@@ -753,23 +783,28 @@ namespace Unity.Netcode
 
                     for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                     {
-                        m_Hooks[hookIdx].OnBeforeSendBatch(clientId, queueItem.BatchHeader.BatchSize, queueItem.Writer.Length, queueItem.NetworkDelivery);
+                        m_Hooks[hookIdx].OnBeforeSendBatch(clientId, queueItem.BatchHeader.BatchCount, queueItem.Writer.Length, queueItem.NetworkDelivery);
                     }
 
                     queueItem.Writer.Seek(0);
 #if UNITY_EDITOR || DEVELOPMENT_BUILD
                     // Skipping the Verify and sneaking the write mark in because we know it's fine.
-                    queueItem.Writer.Handle->AllowedWriteMark = 2;
+                    queueItem.Writer.Handle->AllowedWriteMark = sizeof(BatchHeader);
 #endif
+                    queueItem.BatchHeader.BatchHash = XXHash.Hash64(queueItem.Writer.GetUnsafePtr() + sizeof(BatchHeader), queueItem.Writer.Length - sizeof(BatchHeader));
+
+                    queueItem.BatchHeader.BatchSize = queueItem.Writer.Length;
+
                     queueItem.Writer.WriteValue(queueItem.BatchHeader);
 
+
                     try
                     {
                         m_MessageSender.Send(clientId, queueItem.NetworkDelivery, queueItem.Writer);
 
                         for (var hookIdx = 0; hookIdx < m_Hooks.Count; ++hookIdx)
                         {
-                            m_Hooks[hookIdx].OnAfterSendBatch(clientId, queueItem.BatchHeader.BatchSize, queueItem.Writer.Length, queueItem.NetworkDelivery);
+                            m_Hooks[hookIdx].OnAfterSendBatch(clientId, queueItem.BatchHeader.BatchCount, queueItem.Writer.Length, queueItem.NetworkDelivery);
                         }
                     }
                     finally

Runtime/NetworkVariable/NetworkVariable.cs

@@ -1,5 +1,5 @@
-using UnityEngine;
 using System;
+using UnityEngine;
 
 namespace Unity.Netcode
 {

Runtime/NetworkVariable/NetworkVariableBase.cs

@@ -18,6 +18,11 @@ namespace Unity.Netcode
         /// </summary>
         private protected NetworkBehaviour m_NetworkBehaviour;
 
+        public NetworkBehaviour GetBehaviour()
+        {
+            return m_NetworkBehaviour;
+        }
+
         /// <summary>
         /// Initializes the NetworkVariable
         /// </summary>

Runtime/SceneManagement/DefaultSceneManagerHandler.cs

@@ -0,0 +1,377 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    ///  The default SceneManagerHandler that interfaces between the SceneManager and NetworkSceneManager
+    /// </summary>
+    internal class DefaultSceneManagerHandler : ISceneManagerHandler
+    {
+        private Scene m_InvalidScene = new Scene();
+
+        internal struct SceneEntry
+        {
+            public bool IsAssigned;
+            public Scene Scene;
+        }
+
+        internal Dictionary<string, Dictionary<int, SceneEntry>> SceneNameToSceneHandles = new Dictionary<string, Dictionary<int, SceneEntry>>();
+
+        public AsyncOperation LoadSceneAsync(string sceneName, LoadSceneMode loadSceneMode, SceneEventProgress sceneEventProgress)
+        {
+            var operation = SceneManager.LoadSceneAsync(sceneName, loadSceneMode);
+            sceneEventProgress.SetAsyncOperation(operation);
+            return operation;
+        }
+
+        public AsyncOperation UnloadSceneAsync(Scene scene, SceneEventProgress sceneEventProgress)
+        {
+            var operation = SceneManager.UnloadSceneAsync(scene);
+            sceneEventProgress.SetAsyncOperation(operation);
+            return operation;
+        }
+
+        /// <summary>
+        /// Resets scene tracking
+        /// </summary>
+        public void ClearSceneTracking(NetworkManager networkManager)
+        {
+            SceneNameToSceneHandles.Clear();
+        }
+
+        /// <summary>
+        /// Stops tracking a specific scene
+        /// </summary>
+        public void StopTrackingScene(int handle, string name, NetworkManager networkManager)
+        {
+            if (SceneNameToSceneHandles.ContainsKey(name))
+            {
+                if (SceneNameToSceneHandles[name].ContainsKey(handle))
+                {
+                    SceneNameToSceneHandles[name].Remove(handle);
+                    if (SceneNameToSceneHandles[name].Count == 0)
+                    {
+                        SceneNameToSceneHandles.Remove(name);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Starts tracking a specific scene
+        /// </summary>
+        public void StartTrackingScene(Scene scene, bool assigned, NetworkManager networkManager)
+        {
+            if (!SceneNameToSceneHandles.ContainsKey(scene.name))
+            {
+                SceneNameToSceneHandles.Add(scene.name, new Dictionary<int, SceneEntry>());
+            }
+
+            if (!SceneNameToSceneHandles[scene.name].ContainsKey(scene.handle))
+            {
+                var sceneEntry = new SceneEntry()
+                {
+                    IsAssigned = true,
+                    Scene = scene
+                };
+                SceneNameToSceneHandles[scene.name].Add(scene.handle, sceneEntry);
+            }
+            else
+            {
+                throw new Exception($"[Duplicate Handle] Scene {scene.name} already has scene handle {scene.handle} registered!");
+            }
+        }
+
+        /// <summary>
+        /// Determines if there is an existing scene loaded that matches the scene name but has not been assigned
+        /// </summary>
+        public bool DoesSceneHaveUnassignedEntry(string sceneName, NetworkManager networkManager)
+        {
+            var scenesWithSceneName = new List<Scene>();
+
+            // Get all loaded scenes with the same name
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                if (scene.name == sceneName)
+                {
+                    scenesWithSceneName.Add(scene);
+                }
+            }
+
+            // If there are no scenes of this name loaded then we have no loaded scenes
+            // to use
+            if (scenesWithSceneName.Count == 0)
+            {
+                return false;
+            }
+
+            // If we have 1 or more scenes with the name and we have no entries, then we do have
+            // a scene to use
+            if (scenesWithSceneName.Count > 0 && !SceneNameToSceneHandles.ContainsKey(sceneName))
+            {
+                return true;
+            }
+
+            // Determine if any of the loaded scenes has been used for synchronizing
+            foreach (var scene in scenesWithSceneName)
+            {
+                // If we don't have the handle, then we can use that scene
+                if (!SceneNameToSceneHandles[scene.name].ContainsKey(scene.handle))
+                {
+                    return true;
+                }
+
+                // If we have an entry, but it is not yet assigned (i.e. preloaded)
+                // then we can use that.
+                if (!SceneNameToSceneHandles[scene.name][scene.handle].IsAssigned)
+                {
+                    return true;
+                }
+            }
+            // If none were found, then we have no available scene (which most likely means one will get loaded)
+            return false;
+        }
+
+        /// <summary>
+        /// This will find any scene entry that hasn't been used/assigned, set the entry to assigned, and
+        /// return the associated scene. If none are found it returns an invalid scene.
+        /// </summary>
+        public Scene GetSceneFromLoadedScenes(string sceneName, NetworkManager networkManager)
+        {
+            if (SceneNameToSceneHandles.ContainsKey(sceneName))
+            {
+                foreach (var sceneHandleEntry in SceneNameToSceneHandles[sceneName])
+                {
+                    if (!sceneHandleEntry.Value.IsAssigned)
+                    {
+                        var sceneEntry = sceneHandleEntry.Value;
+                        sceneEntry.IsAssigned = true;
+                        SceneNameToSceneHandles[sceneName][sceneHandleEntry.Key] = sceneEntry;
+                        return sceneEntry.Scene;
+                    }
+                }
+            }
+            // If we found nothing return an invalid scene
+            return m_InvalidScene;
+        }
+
+        /// <summary>
+        /// Only invoked is client synchronization is additive, this will generate the scene tracking table
+        /// in order to re-use the same scenes the server is synchronizing instead of having to unload the
+        /// scenes and reload them when synchronizing (i.e. client disconnects due to external reason, the
+        /// same application instance is still running, the same scenes are still loaded on the client, and
+        /// upon reconnecting the client doesn't have to unload the scenes and then reload them)
+        /// </summary>
+        public void PopulateLoadedScenes(ref Dictionary<int, Scene> scenesLoaded, NetworkManager networkManager)
+        {
+            SceneNameToSceneHandles.Clear();
+            var sceneCount = SceneManager.sceneCount;
+            for (int i = 0; i < sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                if (!SceneNameToSceneHandles.ContainsKey(scene.name))
+                {
+                    SceneNameToSceneHandles.Add(scene.name, new Dictionary<int, SceneEntry>());
+                }
+
+                if (!SceneNameToSceneHandles[scene.name].ContainsKey(scene.handle))
+                {
+                    var sceneEntry = new SceneEntry()
+                    {
+                        IsAssigned = false,
+                        Scene = scene
+                    };
+                    SceneNameToSceneHandles[scene.name].Add(scene.handle, sceneEntry);
+                    if (!scenesLoaded.ContainsKey(scene.handle))
+                    {
+                        scenesLoaded.Add(scene.handle, scene);
+                    }
+                }
+                else
+                {
+                    throw new Exception($"[Duplicate Handle] Scene {scene.name} already has scene handle {scene.handle} registered!");
+                }
+            }
+        }
+
+        private List<Scene> m_ScenesToUnload = new List<Scene>();
+
+        /// <summary>
+        /// Unloads any scenes that have not been assigned.
+        /// </summary>
+        /// <param name="networkManager"></param>
+        public void UnloadUnassignedScenes(NetworkManager networkManager = null)
+        {
+            var sceneManager = networkManager.SceneManager;
+            SceneManager.sceneUnloaded += SceneManager_SceneUnloaded;
+            foreach (var sceneEntry in SceneNameToSceneHandles)
+            {
+                var scenHandleEntries = SceneNameToSceneHandles[sceneEntry.Key];
+                foreach (var sceneHandleEntry in scenHandleEntries)
+                {
+                    if (!sceneHandleEntry.Value.IsAssigned)
+                    {
+                        if (sceneManager.VerifySceneBeforeUnloading == null || sceneManager.VerifySceneBeforeUnloading.Invoke(sceneHandleEntry.Value.Scene))
+                        {
+                            m_ScenesToUnload.Add(sceneHandleEntry.Value.Scene);
+                        }
+                    }
+                }
+            }
+            foreach (var sceneToUnload in m_ScenesToUnload)
+            {
+                SceneManager.UnloadSceneAsync(sceneToUnload);
+            }
+        }
+
+        private void SceneManager_SceneUnloaded(Scene scene)
+        {
+            if (SceneNameToSceneHandles.ContainsKey(scene.name))
+            {
+                if (SceneNameToSceneHandles[scene.name].ContainsKey(scene.handle))
+                {
+                    SceneNameToSceneHandles[scene.name].Remove(scene.handle);
+                }
+                if (SceneNameToSceneHandles[scene.name].Count == 0)
+                {
+                    SceneNameToSceneHandles.Remove(scene.name);
+                }
+                m_ScenesToUnload.Remove(scene);
+                if (m_ScenesToUnload.Count == 0)
+                {
+                    SceneManager.sceneUnloaded -= SceneManager_SceneUnloaded;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Handles determining if a client should attempt to load a scene during synchronization.
+        /// </summary>
+        /// <param name="sceneName">name of the scene to be loaded</param>
+        /// <param name="isPrimaryScene">when in client synchronization mode single, this determines if the scene is the primary active scene</param>
+        /// <param name="clientSynchronizationMode">the current client synchronization mode</param>
+        /// <param name="networkManager"><see cref="NetworkManager"/> instance</param>
+        /// <returns></returns>
+        public bool ClientShouldPassThrough(string sceneName, bool isPrimaryScene, LoadSceneMode clientSynchronizationMode, NetworkManager networkManager)
+        {
+            var shouldPassThrough = clientSynchronizationMode == LoadSceneMode.Single ? false : DoesSceneHaveUnassignedEntry(sceneName, networkManager);
+            var activeScene = SceneManager.GetActiveScene();
+
+            // If shouldPassThrough is not yet true and the scene to be loaded is the currently active scene
+            if (!shouldPassThrough && sceneName == activeScene.name)
+            {
+                // In additive mode we always pass through, but in LoadSceneMode.Single we only pass through if the currently active scene
+                // is the primary scene to be loaded
+                if (clientSynchronizationMode == LoadSceneMode.Additive || (isPrimaryScene && clientSynchronizationMode == LoadSceneMode.Single))
+                {
+                    // don't try to reload this scene and pass through to post load processing.
+                    shouldPassThrough = true;
+                }
+            }
+            return shouldPassThrough;
+        }
+
+        /// <summary>
+        /// Handles migrating dynamically spawned NetworkObjects to the DDOL when a scene is unloaded
+        /// </summary>
+        /// <param name="networkManager"><see cref="NetworkManager"/>relative instance</param>
+        /// <param name="scene">scene being unloaded</param>
+        public void MoveObjectsFromSceneToDontDestroyOnLoad(ref NetworkManager networkManager, Scene scene)
+        {
+            bool isActiveScene = scene == SceneManager.GetActiveScene();
+            // Create a local copy of the spawned objects list since the spawn manager will adjust the list as objects
+            // are despawned.
+            var localSpawnedObjectsHashSet = new HashSet<NetworkObject>(networkManager.SpawnManager.SpawnedObjectsList);
+            foreach (var networkObject in localSpawnedObjectsHashSet)
+            {
+                if (networkObject == null || (networkObject != null && networkObject.gameObject.scene.handle != scene.handle))
+                {
+                    continue;
+                }
+
+                // Only NetworkObjects marked to not be destroyed with the scene and are not already in the DDOL are preserved
+                if (!networkObject.DestroyWithScene && networkObject.gameObject.scene != networkManager.SceneManager.DontDestroyOnLoadScene)
+                {
+                    // Only move dynamically spawned NetworkObjects with no parent as the children will follow
+                    if (networkObject.gameObject.transform.parent == null && networkObject.IsSceneObject != null && !networkObject.IsSceneObject.Value)
+                    {
+                        UnityEngine.Object.DontDestroyOnLoad(networkObject.gameObject);
+                    }
+                }
+                else if (networkManager.IsServer)
+                {
+                    networkObject.Despawn();
+                }
+                else // We are a client, migrate the object into the DDOL temporarily until it receives the destroy command from the server
+                {
+                    UnityEngine.Object.DontDestroyOnLoad(networkObject.gameObject);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sets the client synchronization mode which impacts whether both the server or client take into consideration scenes loaded before
+        /// starting the <see cref="NetworkManager"/>.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="LoadSceneMode.Single"/>: Does not take preloaded scenes into consideration
+        /// <see cref="LoadSceneMode.Single"/>: Does take preloaded scenes into consideration
+        /// </remarks>
+        /// <param name="networkManager">relative <see cref="NetworkManager"/> instance</param>
+        /// <param name="mode"><see cref="LoadSceneMode.Single"/> or <see cref="LoadSceneMode.Additive"/></param>
+        public void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode)
+        {
+            var sceneManager = networkManager.SceneManager;
+            // Don't let client's set this value
+            if (!networkManager.IsServer)
+            {
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                {
+                    NetworkLog.LogWarning("Clients should not set this value as it is automatically synchronized with the server's setting!");
+                }
+                return;
+            }
+            else // Warn users if they are changing this after there are clients already connected and synchronized
+            if (networkManager.ConnectedClientsIds.Count > (networkManager.IsServer ? 0 : 1) && sceneManager.ClientSynchronizationMode != mode)
+            {
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                {
+                    NetworkLog.LogWarning("Server is changing client synchronization mode after clients have been synchronized! It is recommended to do this before clients are connected!");
+                }
+            }
+
+            // For additive client synchronization, we take into consideration scenes
+            // already loaded.
+            if (mode == LoadSceneMode.Additive)
+            {
+                for (int i = 0; i < SceneManager.sceneCount; i++)
+                {
+                    var scene = SceneManager.GetSceneAt(i);
+
+                    // If using scene verification
+                    if (sceneManager.VerifySceneBeforeLoading != null)
+                    {
+                        // Determine if we should take this scene into consideration
+                        if (!sceneManager.VerifySceneBeforeLoading.Invoke(scene.buildIndex, scene.name, LoadSceneMode.Additive))
+                        {
+                            continue;
+                        }
+                    }
+
+                    // If the scene is not already in the ScenesLoaded list, then add it
+                    if (!sceneManager.ScenesLoaded.ContainsKey(scene.handle))
+                    {
+                        sceneManager.ScenesLoaded.Add(scene.handle, scene);
+                    }
+                }
+            }
+            // Set the client synchronization mode
+            sceneManager.ClientSynchronizationMode = mode;
+        }
+    }
+}

Runtime/SceneManagement/DefaultSceneManagerHandler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8c18076bb9734cf4ea7297f85b7729be
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Runtime/SceneManagement/ISceneManagerHandler.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 
@@ -12,5 +13,24 @@ namespace Unity.Netcode
         AsyncOperation LoadSceneAsync(string sceneName, LoadSceneMode loadSceneMode, SceneEventProgress sceneEventProgress);
 
         AsyncOperation UnloadSceneAsync(Scene scene, SceneEventProgress sceneEventProgress);
+
+        void PopulateLoadedScenes(ref Dictionary<int, Scene> scenesLoaded, NetworkManager networkManager = null);
+        Scene GetSceneFromLoadedScenes(string sceneName, NetworkManager networkManager = null);
+
+        bool DoesSceneHaveUnassignedEntry(string sceneName, NetworkManager networkManager = null);
+
+        void StopTrackingScene(int handle, string name, NetworkManager networkManager = null);
+
+        void StartTrackingScene(Scene scene, bool assigned, NetworkManager networkManager = null);
+
+        void ClearSceneTracking(NetworkManager networkManager = null);
+
+        void UnloadUnassignedScenes(NetworkManager networkManager = null);
+
+        void MoveObjectsFromSceneToDontDestroyOnLoad(ref NetworkManager networkManager, Scene scene);
+
+        void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode);
+
+        bool ClientShouldPassThrough(string sceneName, bool isPrimaryScene, LoadSceneMode clientSynchronizationMode, NetworkManager networkManager);
     }
 }

Runtime/SceneManagement/SceneEventData.cs

@@ -1,5 +1,5 @@
-using System.Collections.Generic;
 using System;
+using System.Collections.Generic;
 using System.Linq;
 using Unity.Collections;
 using UnityEngine.SceneManagement;
@@ -80,6 +80,16 @@ namespace Unity.Netcode
         /// <b>Event Notification:</b> Both server and client receive a local notification.
         /// </summary>
         SynchronizeComplete,
+        /// <summary>
+        /// Synchronizes clients when the active scene has changed
+        /// See: <see cref="NetworkObject.ActiveSceneSynchronization"/>
+        /// </summary>
+        ActiveSceneChanged,
+        /// <summary>
+        /// Synchronizes clients when one or more NetworkObjects are migrated into a new scene
+        /// See: <see cref="NetworkObject.SceneMigrationSynchronization"/>
+        /// </summary>
+        ObjectSceneChanged,
     }
 
     /// <summary>
@@ -94,7 +104,7 @@ namespace Unity.Netcode
         internal ForceNetworkSerializeByMemcpy<Guid> SceneEventProgressId;
         internal uint SceneEventId;
 
-
+        internal uint ActiveSceneHash;
         internal uint SceneHash;
         internal int SceneHandle;
 
@@ -139,6 +149,8 @@ namespace Unity.Netcode
         internal Queue<uint> ScenesToSynchronize;
         internal Queue<uint> SceneHandlesToSynchronize;
 
+        internal LoadSceneMode ClientSynchronizationMode;
+
 
         /// <summary>
         /// Server Side:
@@ -315,6 +327,8 @@ namespace Unity.Netcode
                 case SceneEventType.ReSynchronize:
                 case SceneEventType.LoadEventCompleted:
                 case SceneEventType.UnloadEventCompleted:
+                case SceneEventType.ActiveSceneChanged:
+                case SceneEventType.ObjectSceneChanged:
                     {
                         return true;
                     }
@@ -384,6 +398,18 @@ namespace Unity.Netcode
             // Write the scene event type
             writer.WriteValueSafe(SceneEventType);
 
+            if (SceneEventType == SceneEventType.ActiveSceneChanged)
+            {
+                writer.WriteValueSafe(ActiveSceneHash);
+                return;
+            }
+
+            if (SceneEventType == SceneEventType.ObjectSceneChanged)
+            {
+                SerializeObjectsMovedIntoNewScene(writer);
+                return;
+            }
+
             // Write the scene loading mode
             writer.WriteValueSafe((byte)LoadSceneMode);
 
@@ -392,6 +418,10 @@ namespace Unity.Netcode
             {
                 writer.WriteValueSafe(SceneEventProgressId);
             }
+            else
+            {
+                writer.WriteValueSafe(ClientSynchronizationMode);
+            }
 
             // Write the scene index and handle
             writer.WriteValueSafe(SceneHash);
@@ -401,6 +431,7 @@ namespace Unity.Netcode
             {
                 case SceneEventType.Synchronize:
                     {
+                        writer.WriteValueSafe(ActiveSceneHash);
                         WriteSceneSynchronizationData(writer);
                         break;
                     }
@@ -445,7 +476,7 @@ namespace Unity.Netcode
             // Size Place Holder -- Start
             // !!NOTE!!: Since this is a placeholder to be set after we know how much we have written,
             // for stream offset purposes this MUST not be a packed value!
-            writer.WriteValueSafe((int)0);
+            writer.WriteValueSafe(0);
             int totalBytes = 0;
 
             // Write the number of NetworkObjects we are serializing
@@ -458,7 +489,7 @@ namespace Unity.Netcode
                 var sceneObject = m_NetworkObjectsSync[i].GetMessageSceneObject(TargetClientId);
                 sceneObject.Serialize(writer);
                 var noStop = writer.Position;
-                totalBytes += (int)(noStop - noStart);
+                totalBytes += noStop - noStart;
             }
 
             // Write the number of despawned in-scene placed NetworkObjects
@@ -470,7 +501,7 @@ namespace Unity.Netcode
                 writer.WriteValueSafe(m_DespawnedInSceneObjectsSync[i].GetSceneOriginHandle());
                 writer.WriteValueSafe(m_DespawnedInSceneObjectsSync[i].GlobalObjectIdHash);
                 var noStop = writer.Position;
-                totalBytes += (int)(noStop - noStart);
+                totalBytes += noStop - noStart;
             }
 
             // Size Place Holder -- End
@@ -536,6 +567,26 @@ namespace Unity.Netcode
         internal void Deserialize(FastBufferReader reader)
         {
             reader.ReadValueSafe(out SceneEventType);
+            if (SceneEventType == SceneEventType.ActiveSceneChanged)
+            {
+                reader.ReadValueSafe(out ActiveSceneHash);
+                return;
+            }
+
+            if (SceneEventType == SceneEventType.ObjectSceneChanged)
+            {
+                // Defer these scene event types if a client hasn't finished synchronizing
+                if (!m_NetworkManager.IsConnectedClient)
+                {
+                    DeferObjectsMovedIntoNewScene(reader);
+                }
+                else
+                {
+                    DeserializeObjectsMovedIntoNewScene(reader);
+                }
+                return;
+            }
+
             reader.ReadValueSafe(out byte loadSceneMode);
             LoadSceneMode = (LoadSceneMode)loadSceneMode;
 
@@ -543,6 +594,10 @@ namespace Unity.Netcode
             {
                 reader.ReadValueSafe(out SceneEventProgressId);
             }
+            else
+            {
+                reader.ReadValueSafe(out ClientSynchronizationMode);
+            }
 
             reader.ReadValueSafe(out SceneHash);
             reader.ReadValueSafe(out SceneHandle);
@@ -551,6 +606,7 @@ namespace Unity.Netcode
             {
                 case SceneEventType.Synchronize:
                     {
+                        reader.ReadValueSafe(out ActiveSceneHash);
                         CopySceneSynchronizationData(reader);
                         break;
                     }
@@ -939,6 +995,143 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// Serialize scene handles and associated NetworkObjects that were migrated
+        /// into a new scene.
+        /// </summary>
+        private void SerializeObjectsMovedIntoNewScene(FastBufferWriter writer)
+        {
+            var sceneManager = m_NetworkManager.SceneManager;
+            // Write the number of scene handles
+            writer.WriteValueSafe(sceneManager.ObjectsMigratedIntoNewScene.Count);
+            foreach (var sceneHandleObjects in sceneManager.ObjectsMigratedIntoNewScene)
+            {
+                // Write the scene handle
+                writer.WriteValueSafe(sceneHandleObjects.Key);
+                // Write the number of NetworkObjectIds to expect
+                writer.WriteValueSafe(sceneHandleObjects.Value.Count);
+                foreach (var networkObject in sceneHandleObjects.Value)
+                {
+                    writer.WriteValueSafe(networkObject.NetworkObjectId);
+                }
+            }
+            // Once we are done, clear the table
+            sceneManager.ObjectsMigratedIntoNewScene.Clear();
+        }
+
+        /// <summary>
+        /// Deserialize scene handles and associated NetworkObjects that need to
+        /// be migrated into a new scene.
+        /// </summary>
+        private void DeserializeObjectsMovedIntoNewScene(FastBufferReader reader)
+        {
+            var sceneManager = m_NetworkManager.SceneManager;
+            var spawnManager = m_NetworkManager.SpawnManager;
+            // Just always assure this has no entries
+            sceneManager.ObjectsMigratedIntoNewScene.Clear();
+            var numberOfScenes = 0;
+            var sceneHandle = 0;
+            var objectCount = 0;
+            var networkObjectId = (ulong)0;
+            reader.ReadValueSafe(out numberOfScenes);
+            for (int i = 0; i < numberOfScenes; i++)
+            {
+                reader.ReadValueSafe(out sceneHandle);
+                sceneManager.ObjectsMigratedIntoNewScene.Add(sceneHandle, new List<NetworkObject>());
+                reader.ReadValueSafe(out objectCount);
+                for (int j = 0; j < objectCount; j++)
+                {
+                    reader.ReadValueSafe(out networkObjectId);
+                    if (!spawnManager.SpawnedObjects.ContainsKey(networkObjectId))
+                    {
+                        NetworkLog.LogError($"[Object Scene Migration] Trying to synchronize NetworkObjectId ({networkObjectId}) but it was not spawned or no longer exists!!");
+                        continue;
+                    }
+                    // Add NetworkObject scene migration to ObjectsMigratedIntoNewScene dictionary that is processed
+                    //
+                    sceneManager.ObjectsMigratedIntoNewScene[sceneHandle].Add(spawnManager.SpawnedObjects[networkObjectId]);
+                }
+            }
+        }
+
+
+        /// <summary>
+        /// While a client is synchronizing ObjectSceneChanged messages could be received.
+        /// This defers any ObjectSceneChanged message processing to occur after the client
+        /// has completed synchronization to assure the associated NetworkObjects being
+        /// migrated to a new scene are instantiated and spawned.
+        /// </summary>
+        private void DeferObjectsMovedIntoNewScene(FastBufferReader reader)
+        {
+            var sceneManager = m_NetworkManager.SceneManager;
+            var spawnManager = m_NetworkManager.SpawnManager;
+            var numberOfScenes = 0;
+            var sceneHandle = 0;
+            var objectCount = 0;
+            var networkObjectId = (ulong)0;
+
+            var deferredObjectsMovedEvent = new NetworkSceneManager.DeferredObjectsMovedEvent()
+            {
+                ObjectsMigratedTable = new Dictionary<int, List<ulong>>()
+            };
+
+            reader.ReadValueSafe(out numberOfScenes);
+            for (int i = 0; i < numberOfScenes; i++)
+            {
+                reader.ReadValueSafe(out sceneHandle);
+                deferredObjectsMovedEvent.ObjectsMigratedTable.Add(sceneHandle, new List<ulong>());
+                reader.ReadValueSafe(out objectCount);
+                for (int j = 0; j < objectCount; j++)
+                {
+                    reader.ReadValueSafe(out networkObjectId);
+                    deferredObjectsMovedEvent.ObjectsMigratedTable[sceneHandle].Add(networkObjectId);
+                }
+            }
+            sceneManager.DeferredObjectsMovedEvents.Add(deferredObjectsMovedEvent);
+        }
+
+        internal void ProcessDeferredObjectSceneChangedEvents()
+        {
+            var sceneManager = m_NetworkManager.SceneManager;
+            var spawnManager = m_NetworkManager.SpawnManager;
+            if (sceneManager.DeferredObjectsMovedEvents.Count == 0)
+            {
+                return;
+            }
+            foreach (var objectsMovedEvent in sceneManager.DeferredObjectsMovedEvents)
+            {
+                foreach (var keyEntry in objectsMovedEvent.ObjectsMigratedTable)
+                {
+                    if (!sceneManager.ObjectsMigratedIntoNewScene.ContainsKey(keyEntry.Key))
+                    {
+                        sceneManager.ObjectsMigratedIntoNewScene.Add(keyEntry.Key, new List<NetworkObject>());
+                    }
+                    foreach (var objectId in keyEntry.Value)
+                    {
+                        if (!spawnManager.SpawnedObjects.ContainsKey(objectId))
+                        {
+                            NetworkLog.LogWarning($"[Deferred][Object Scene Migration] Trying to synchronize NetworkObjectId ({objectId}) but it was not spawned or no longer exists!");
+                            continue;
+                        }
+                        var networkObject = spawnManager.SpawnedObjects[objectId];
+                        if (!sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key].Contains(networkObject))
+                        {
+                            sceneManager.ObjectsMigratedIntoNewScene[keyEntry.Key].Add(networkObject);
+                        }
+                    }
+                }
+                objectsMovedEvent.ObjectsMigratedTable.Clear();
+            }
+
+            sceneManager.DeferredObjectsMovedEvents.Clear();
+
+            // If there are any pending objects to migrate, then migrate them
+            if (sceneManager.ObjectsMigratedIntoNewScene.Count > 0)
+            {
+                sceneManager.MigrateNetworkObjectsIntoScenes();
+            }
+        }
+
         /// <summary>
         /// Used to release the pooled network buffer
         /// </summary>

Runtime/SceneManagement/SceneEventProgress.cs

@@ -83,7 +83,7 @@ namespace Unity.Netcode
         /// </summary>
         internal bool HasTimedOut()
         {
-            return WhenSceneEventHasTimedOut <= Time.realtimeSinceStartup;
+            return WhenSceneEventHasTimedOut <= m_NetworkManager.RealTimeProvider.RealTimeSinceStartup;
         }
 
         /// <summary>
@@ -164,7 +164,7 @@ namespace Unity.Netcode
                         ClientsProcessingSceneEvent.Add(connectedClientId, false);
                     }
 
-                    WhenSceneEventHasTimedOut = Time.realtimeSinceStartup + networkManager.NetworkConfig.LoadSceneTimeOut;
+                    WhenSceneEventHasTimedOut = networkManager.RealTimeProvider.RealTimeSinceStartup + networkManager.NetworkConfig.LoadSceneTimeOut;
                     m_TimeOutCoroutine = m_NetworkManager.StartCoroutine(TimeOutSceneEventProgress());
                 }
             }

Runtime/Serialization/BufferSerializer.cs

@@ -7,14 +7,10 @@ namespace Unity.Netcode
     /// <summary>
     /// Two-way serializer wrapping FastBufferReader or FastBufferWriter.
     ///
-    /// Implemented as a ref struct for two reasons:
+    /// Implemented as a ref struct to help enforce the requirement that
-    /// 1. The BufferSerializer cannot outlive the FBR/FBW it wraps or using it will cause a crash
+    /// the BufferSerializer cannot outlive the FBR/FBW it wraps or using it will cause a crash
-    /// 2. The BufferSerializer must always be passed by reference and can't be copied
     ///
-    /// Ref structs help enforce both of those rules: they can't ref live the stack context in which they were
+    /// BufferSerializer doesn't wrap FastBufferReader or FastBufferWriter directly because it can't.
-    /// created, and they're always passed by reference no matter what.
-    ///
-    /// BufferSerializer doesn't wrapp FastBufferReader or FastBufferWriter directly because it can't.
     /// ref structs can't implement interfaces, and in order to be able to have two different implementations with
     /// the same interface (which allows us to avoid an "if(IsReader)" on every call), the thing directly wrapping
     /// the struct has to implement an interface. So IReaderWriter exists as the interface,

Runtime/Serialization/FastBufferReader.cs

@@ -1299,8 +1299,10 @@ namespace Unity.Netcode
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
             ReadUnmanaged(out int length);
-            value = new T();
+            value = new T
-            value.Length = length;
+            {
+                Length = length
+            };
             ReadBytes(value.GetUnsafePtr(), length);
         }
 
@@ -1319,8 +1321,10 @@ namespace Unity.Netcode
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
             ReadUnmanagedSafe(out int length);
-            value = new T();
+            value = new T
-            value.Length = length;
+            {
+                Length = length
+            };
             ReadBytesSafe(value.GetUnsafePtr(), length);
         }
 

Runtime/Serialization/NetworkObjectReference.cs

@@ -54,13 +54,7 @@ namespace Unity.Netcode
                 throw new ArgumentNullException(nameof(gameObject));
             }
 
-            var networkObject = gameObject.GetComponent<NetworkObject>();
+            var networkObject = gameObject.GetComponent<NetworkObject>() ?? throw new ArgumentException($"Cannot create {nameof(NetworkObjectReference)} from {nameof(GameObject)} without a {nameof(NetworkObject)} component.");
-
-            if (networkObject == null)
-            {
-                throw new ArgumentException($"Cannot create {nameof(NetworkObjectReference)} from {nameof(GameObject)} without a {nameof(NetworkObject)} component.");
-            }
-
             if (networkObject.IsSpawned == false)
             {
                 throw new ArgumentException($"{nameof(NetworkObjectReference)} can only be created from spawned {nameof(NetworkObject)}s.");
@@ -90,7 +84,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static NetworkObject Resolve(NetworkObjectReference networkObjectRef, NetworkManager networkManager = null)
         {
-            networkManager = networkManager != null ? networkManager : NetworkManager.Singleton;
+            networkManager = networkManager ?? NetworkManager.Singleton;
             networkManager.SpawnManager.SpawnedObjects.TryGetValue(networkObjectRef.m_NetworkObjectId, out NetworkObject networkObject);
 
             return networkObject;

Runtime/Spawning/NetworkSpawnManager.cs

@@ -154,7 +154,7 @@ namespace Unity.Netcode
 
         internal ulong GetNetworkObjectId()
         {
-            if (ReleasedNetworkObjectIds.Count > 0 && NetworkManager.NetworkConfig.RecycleNetworkIds && (Time.unscaledTime - ReleasedNetworkObjectIds.Peek().ReleaseTime) >= NetworkManager.NetworkConfig.NetworkIdRecycleDelay)
+            if (ReleasedNetworkObjectIds.Count > 0 && NetworkManager.NetworkConfig.RecycleNetworkIds && (NetworkManager.RealTimeProvider.UnscaledTime - ReleasedNetworkObjectIds.Peek().ReleaseTime) >= NetworkManager.NetworkConfig.NetworkIdRecycleDelay)
             {
                 return ReleasedNetworkObjectIds.Dequeue().NetworkId;
             }
@@ -300,7 +300,7 @@ namespace Unity.Netcode
                 {
                     return true;
                 }
-                if (NetworkManager.NetworkConfig.NetworkPrefabOverrideLinks.TryGetValue(sceneObject.Hash, out var networkPrefab))
+                if (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.TryGetValue(sceneObject.Hash, out var networkPrefab))
                 {
                     switch (networkPrefab.Override)
                     {
@@ -352,17 +352,17 @@ namespace Unity.Netcode
                 {
                     // See if there is a valid registered NetworkPrefabOverrideLink associated with the provided prefabHash
                     GameObject networkPrefabReference = null;
-                    if (NetworkManager.NetworkConfig.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash))
+                    if (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks.ContainsKey(globalObjectIdHash))
                     {
-                        switch (NetworkManager.NetworkConfig.NetworkPrefabOverrideLinks[globalObjectIdHash].Override)
+                        switch (NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].Override)
                         {
                             default:
                             case NetworkPrefabOverride.None:
-                                networkPrefabReference = NetworkManager.NetworkConfig.NetworkPrefabOverrideLinks[globalObjectIdHash].Prefab;
+                                networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].Prefab;
                                 break;
                             case NetworkPrefabOverride.Hash:
                             case NetworkPrefabOverride.Prefab:
-                                networkPrefabReference = NetworkManager.NetworkConfig.NetworkPrefabOverrideLinks[globalObjectIdHash].OverridingTargetPrefab;
+                                networkPrefabReference = NetworkManager.NetworkConfig.Prefabs.NetworkPrefabOverrideLinks[globalObjectIdHash].OverridingTargetPrefab;
                                 break;
                         }
                     }
@@ -405,6 +405,9 @@ namespace Unity.Netcode
 
             if (networkObject != null)
             {
+                networkObject.DestroyWithScene = sceneObject.DestroyWithScene;
+                networkObject.NetworkSceneHandle = sceneObject.NetworkSceneHandle;
+
                 // SPECIAL CASE FOR IN-SCENE PLACED:  (only when the parent has a NetworkObject)
                 // This is a special case scenario where a late joining client has joined and loaded one or
                 // more scenes that contain nested in-scene placed NetworkObject children yet the server's
@@ -603,8 +606,19 @@ namespace Unity.Netcode
             var children = networkObject.GetComponentsInChildren<NetworkObject>();
             foreach (var childObject in children)
             {
+                // Do not propagate the in-scene object setting if a child was dynamically spawned.
+                if (childObject.IsSceneObject.HasValue && !childObject.IsSceneObject.Value)
+                {
+                    continue;
+                }
                 childObject.IsSceneObject = sceneObject;
             }
+
+            // Only dynamically spawned NetworkObjects are allowed
+            if (!sceneObject)
+            {
+                networkObject.SubscribeToActiveSceneForSynch();
+            }
         }
 
         internal void SendSpawnCallForObject(ulong clientId, NetworkObject networkObject)
@@ -843,7 +857,7 @@ namespace Unity.Netcode
                     ReleasedNetworkObjectIds.Enqueue(new ReleasedNetworkId()
                     {
                         NetworkId = networkObject.NetworkObjectId,
-                        ReleaseTime = Time.unscaledTime
+                        ReleaseTime = NetworkManager.RealTimeProvider.UnscaledTime
                     });
                 }
 

Runtime/Timing/IRealTimeProvider.cs

@@ -0,0 +1,10 @@
+namespace Unity.Netcode
+{
+    internal interface IRealTimeProvider
+    {
+        float RealTimeSinceStartup { get; }
+        float UnscaledTime { get; }
+        float UnscaledDeltaTime { get; }
+        float DeltaTime { get; }
+    }
+}

Runtime/Timing/IRealTimeProvider.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 73bdda41e36846e893fd14dbd6de9978
+timeCreated: 1679413210

Runtime/Timing/RealTimeProvider.cs

@@ -0,0 +1,12 @@
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    internal class RealTimeProvider : IRealTimeProvider
+    {
+        public float RealTimeSinceStartup => Time.realtimeSinceStartup;
+        public float UnscaledTime => Time.unscaledTime;
+        public float UnscaledDeltaTime => Time.unscaledDeltaTime;
+        public float DeltaTime => Time.deltaTime;
+    }
+}

Runtime/Timing/RealTimeProvider.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5aa5470767d64d8e89ac69ff52a8c404
+timeCreated: 1679413182

Runtime/Transports/UNET/UNetTransport.cs

@@ -149,7 +149,7 @@ namespace Unity.Netcode.Transports.UNET
             var eventType = UnityEngine.Networking.NetworkTransport.Receive(out int hostId, out int connectionId, out _, m_MessageBuffer, m_MessageBuffer.Length, out int receivedSize, out byte error);
 
             clientId = GetNetcodeClientId((byte)hostId, (ushort)connectionId, false);
-            receiveTime = Time.realtimeSinceStartup;
+            receiveTime = NetworkManager.RealTimeProvider.RealTimeSinceStartup;
 
             var networkError = (NetworkError)error;
             if (networkError == NetworkError.MessageToLong)
@@ -214,7 +214,7 @@ namespace Unity.Netcode.Transports.UNET
         {
             GetUNetConnectionDetails(clientId, out byte hostId, out ushort connectionId);
 
-            UnityEngine.Networking.NetworkTransport.Disconnect((int)hostId, (int)connectionId, out byte error);
+            UnityEngine.Networking.NetworkTransport.Disconnect(hostId, connectionId, out byte error);
         }
 
         public override void DisconnectLocalClient()
@@ -226,7 +226,7 @@ namespace Unity.Netcode.Transports.UNET
         {
             GetUNetConnectionDetails(clientId, out byte hostId, out ushort connectionId);
 
-            return (ulong)UnityEngine.Networking.NetworkTransport.GetCurrentRTT((int)hostId, (int)connectionId, out byte error);
+            return (ulong)UnityEngine.Networking.NetworkTransport.GetCurrentRTT(hostId, connectionId, out byte error);
         }
 
         public override void Shutdown()

Runtime/Transports/UTP/BatchedSendQueue.cs

@@ -226,7 +226,7 @@ namespace Unity.Netcode.Transports.UTP
                     {
                         writer.WriteInt(messageLength);
 
-                        var messageOffset = HeadIndex + reader.GetBytesRead();
+                        var messageOffset = reader.GetBytesRead();
                         WriteBytes(ref writer, (byte*)m_Data.GetUnsafePtr() + messageOffset, messageLength);
 
                         writerAvailable -= sizeof(int) + messageLength;

Runtime/Transports/UTP/UnityTransport.cs

@@ -145,7 +145,7 @@ namespace Unity.Netcode.Transports.UTP
 
         // Maximum reliable throughput, assuming the full reliable window can be sent on every
         // frame at 60 FPS. This will be a large over-estimation in any realistic scenario.
-        private const int k_MaxReliableThroughput = (NetworkParameterConstants.MTU * 32 * 60) / 1000; // bytes per millisecond
+        private const int k_MaxReliableThroughput = (NetworkParameterConstants.MTU * 64 * 60) / 1000; // bytes per millisecond
 
         private static ConnectionAddressData s_DefaultConnectionAddressData = new ConnectionAddressData { Address = "127.0.0.1", Port = 7777, ServerListenAddress = string.Empty };
 
@@ -303,20 +303,23 @@ namespace Unity.Netcode.Transports.UTP
             public ushort Port;
 
             /// <summary>
-            /// IP address the server will listen on. If not provided, will use 'Address'.
+            /// IP address the server will listen on. If not provided, will use localhost.
             /// </summary>
-            [Tooltip("IP address the server will listen on. If not provided, will use 'Address'.")]
+            [Tooltip("IP address the server will listen on. If not provided, will use localhost.")]
             [SerializeField]
             public string ServerListenAddress;
 
-            private static NetworkEndpoint ParseNetworkEndpoint(string ip, ushort port)
+            private static NetworkEndpoint ParseNetworkEndpoint(string ip, ushort port, bool silent = false)
             {
                 NetworkEndpoint endpoint = default;
 
                 if (!NetworkEndpoint.TryParse(ip, port, out endpoint, NetworkFamily.Ipv4) &&
                     !NetworkEndpoint.TryParse(ip, port, out endpoint, NetworkFamily.Ipv6))
                 {
-                    Debug.LogError($"Invalid network endpoint: {ip}:{port}.");
+                    if (!silent)
+                    {
+                        Debug.LogError($"Invalid network endpoint: {ip}:{port}.");
+                    }
                 }
 
                 return endpoint;
@@ -330,9 +333,34 @@ namespace Unity.Netcode.Transports.UTP
             /// <summary>
             /// Endpoint (IP address and port) server will listen/bind on.
             /// </summary>
-            public NetworkEndpoint ListenEndPoint => ParseNetworkEndpoint((ServerListenAddress?.Length == 0) ? Address : ServerListenAddress, Port);
+            public NetworkEndpoint ListenEndPoint
+            {
+                get
+                {
+                    if (string.IsNullOrEmpty(ServerListenAddress))
+                    {
+                        var ep = NetworkEndpoint.LoopbackIpv4;
+
+                        // If an address was entered and it's IPv6, switch to using ::1 as the
+                        // default listen address. (Otherwise we always assume IPv4.)
+                        if (!string.IsNullOrEmpty(Address) && ServerEndPoint.Family == NetworkFamily.Ipv6)
+                        {
+                            ep = NetworkEndpoint.LoopbackIpv6;
+                        }
+
+                        return ep.WithPort(Port);
+                    }
+                    else
+                    {
+                        return ParseNetworkEndpoint(ServerListenAddress, Port);
+                    }
+                }
+            }
+
+            public bool IsIpv6 => !string.IsNullOrEmpty(Address) && ParseNetworkEndpoint(Address, Port, true).Family == NetworkFamily.Ipv6;
         }
 
+
         /// <summary>
         /// The connection (address) data for this <see cref="UnityTransport"/> instance.
         /// This is where you can change IP Address, Port, or server's listen address.
@@ -422,6 +450,8 @@ namespace Unity.Netcode.Transports.UTP
 
         internal NetworkManager NetworkManager;
 
+        private IRealTimeProvider m_RealTimeProvider;
+
         /// <summary>
         /// SendQueue dictionary is used to batch events instead of sending them immediately.
         /// </summary>
@@ -529,14 +559,14 @@ namespace Unity.Netcode.Transports.UTP
             int result = m_Driver.Bind(endPoint);
             if (result != 0)
             {
-                Debug.LogError("Server failed to bind");
+                Debug.LogError("Server failed to bind. This is usually caused by another process being bound to the same port.");
                 return false;
             }
 
             result = m_Driver.Listen();
             if (result != 0)
             {
-                Debug.LogError("Server failed to listen");
+                Debug.LogError("Server failed to listen.");
                 return false;
             }
 
@@ -609,7 +639,7 @@ namespace Unity.Netcode.Transports.UTP
             {
                 Address = ipv4Address,
                 Port = port,
-                ServerListenAddress = listenAddress ?? string.Empty
+                ServerListenAddress = listenAddress ?? ipv4Address
             };
 
             SetProtocol(ProtocolType.UnityTransport);
@@ -735,6 +765,10 @@ namespace Unity.Netcode.Transports.UTP
         // Send as many batched messages from the queue as possible.
         private void SendBatchedMessages(SendTarget sendTarget, BatchedSendQueue queue)
         {
+            if (!m_Driver.IsCreated)
+            {
+                return;
+            }
             new SendBatchedMessagesJob
             {
                 Driver = m_Driver.ToConcurrent(),
@@ -756,7 +790,7 @@ namespace Unity.Netcode.Transports.UTP
             InvokeOnTransportEvent(NetcodeNetworkEvent.Connect,
                 ParseClientId(connection),
                 default,
-                Time.realtimeSinceStartup);
+                m_RealTimeProvider.RealTimeSinceStartup);
 
             return true;
 
@@ -791,7 +825,7 @@ namespace Unity.Netcode.Transports.UTP
                     break;
                 }
 
-                InvokeOnTransportEvent(NetcodeNetworkEvent.Data, clientId, message, Time.realtimeSinceStartup);
+                InvokeOnTransportEvent(NetcodeNetworkEvent.Data, clientId, message, m_RealTimeProvider.RealTimeSinceStartup);
             }
         }
 
@@ -807,7 +841,7 @@ namespace Unity.Netcode.Transports.UTP
                         InvokeOnTransportEvent(NetcodeNetworkEvent.Connect,
                             clientId,
                             default,
-                            Time.realtimeSinceStartup);
+                            m_RealTimeProvider.RealTimeSinceStartup);
 
                         m_State = State.Connected;
                         return true;
@@ -835,7 +869,7 @@ namespace Unity.Netcode.Transports.UTP
                         InvokeOnTransportEvent(NetcodeNetworkEvent.Disconnect,
                             clientId,
                             default,
-                            Time.realtimeSinceStartup);
+                            m_RealTimeProvider.RealTimeSinceStartup);
 
                         return true;
                     }
@@ -865,7 +899,7 @@ namespace Unity.Netcode.Transports.UTP
                     Debug.LogError("Transport failure! Relay allocation needs to be recreated, and NetworkManager restarted. " +
                         "Use NetworkManager.OnTransportFailure to be notified of such events programmatically.");
 
-                    InvokeOnTransportEvent(NetcodeNetworkEvent.TransportFailure, 0, default, Time.realtimeSinceStartup);
+                    InvokeOnTransportEvent(NetcodeNetworkEvent.TransportFailure, 0, default, m_RealTimeProvider.RealTimeSinceStartup);
                     return;
                 }
 
@@ -1088,7 +1122,7 @@ namespace Unity.Netcode.Transports.UTP
                     InvokeOnTransportEvent(NetcodeNetworkEvent.Disconnect,
                         m_ServerClientId,
                         default,
-                        Time.realtimeSinceStartup);
+                        m_RealTimeProvider.RealTimeSinceStartup);
                 }
             }
         }
@@ -1151,19 +1185,24 @@ namespace Unity.Netcode.Transports.UTP
 
             NetworkManager = networkManager;
 
+            m_RealTimeProvider = NetworkManager ? NetworkManager.RealTimeProvider : new RealTimeProvider();
+
             m_NetworkSettings = new NetworkSettings(Allocator.Persistent);
 
-#if !UNITY_WEBGL
             // If the user sends a message of exactly m_MaxPayloadSize in length, we need to
             // account for the overhead of its length when we store it in the send queue.
             var fragmentationCapacity = m_MaxPayloadSize + BatchedSendQueue.PerMessageOverhead;
-
             m_NetworkSettings.WithFragmentationStageParameters(payloadCapacity: fragmentationCapacity);
-#if !UTP_TRANSPORT_2_0_ABOVE
+
+            // Bump the reliable window size to its maximum size of 64. Since NGO makes heavy use of
+            // reliable delivery, we're better off with the increased window size compared to the
+            // extra 4 bytes of header that this costs us.
+            m_NetworkSettings.WithReliableStageParameters(windowSize: 64);
+
+#if !UTP_TRANSPORT_2_0_ABOVE && !UNITY_WEBGL
             m_NetworkSettings.WithBaselibNetworkInterfaceParameters(
                 receiveQueueCapacity: m_MaxPacketQueueSize,
                 sendQueueCapacity: m_MaxPacketQueueSize);
-#endif
 #endif
         }
 
@@ -1172,7 +1211,7 @@ namespace Unity.Netcode.Transports.UTP
         /// </summary>
         /// <param name="clientId">The clientId this event is for</param>
         /// <param name="payload">The incoming data payload</param>
-        /// <param name="receiveTime">The time the event was received, as reported by Time.realtimeSinceStartup.</param>
+        /// <param name="receiveTime">The time the event was received, as reported by m_RealTimeProvider.RealTimeSinceStartup.</param>
         /// <returns>Returns the event type</returns>
         public override NetcodeNetworkEvent PollEvent(out ulong clientId, out ArraySegment<byte> payload, out float receiveTime)
         {
@@ -1245,7 +1284,7 @@ namespace Unity.Netcode.Transports.UTP
                         InvokeOnTransportEvent(NetcodeNetworkEvent.Disconnect,
                             clientId,
                             default(ArraySegment<byte>),
-                            Time.realtimeSinceStartup);
+                            m_RealTimeProvider.RealTimeSinceStartup);
                     }
                 }
                 else
@@ -1393,6 +1432,10 @@ namespace Unity.Netcode.Transports.UTP
         private string m_ClientCaCertificate;
 
         /// <summary>Set the server parameters for encryption.</summary>
+        /// <remarks>
+        /// The public certificate and private key are expected to be in the PEM format, including
+        /// the begin/end markers like <c>-----BEGIN CERTIFICATE-----</c>.
+        /// </remarks>
         /// <param name="serverCertificate">Public certificate for the server (PEM format).</param>
         /// <param name="serverPrivateKey">Private key for the server (PEM format).</param>
         public void SetServerSecrets(string serverCertificate, string serverPrivateKey)
@@ -1403,9 +1446,15 @@ namespace Unity.Netcode.Transports.UTP
 
         /// <summary>Set the client parameters for encryption.</summary>
         /// <remarks>
+        /// <para>
         /// If the CA certificate is not provided, validation will be done against the OS/browser
         /// certificate store. This is what you'd want if using certificates from a known provider.
         /// For self-signed certificates, the CA certificate needs to be provided.
+        /// </para>
+        /// <para>
+        /// The CA certificate (if provided) is expected to be in the PEM format, including the
+        /// begin/end markers like <c>-----BEGIN CERTIFICATE-----</c>.
+        /// </para>
         /// </remarks>
         /// <param name="serverCommonName">Common name of the server (typically hostname).</param>
         /// <param name="caCertificate">CA certificate used to validate the server's authenticity.</param>
@@ -1449,7 +1498,7 @@ namespace Unity.Netcode.Transports.UTP
                 heartbeatTimeoutMS: transport.m_HeartbeatTimeoutMS);
 
 #if UNITY_WEBGL && !UNITY_EDITOR
-            if (NetworkManager.IsServer)
+            if (NetworkManager.IsServer && m_ProtocolType != ProtocolType.RelayUnityTransport)
             {
                 throw new Exception("WebGL as a server is not supported by Unity Transport, outside the Editor.");
             }
@@ -1473,7 +1522,7 @@ namespace Unity.Netcode.Transports.UTP
                 {
                     if (NetworkManager.IsServer)
                     {
-                        if (String.IsNullOrEmpty(m_ServerCertificate) || String.IsNullOrEmpty(m_ServerPrivateKey))
+                        if (string.IsNullOrEmpty(m_ServerCertificate) || string.IsNullOrEmpty(m_ServerPrivateKey))
                         {
                             throw new Exception("In order to use encrypted communications, when hosting, you must set the server certificate and key.");
                         }
@@ -1482,11 +1531,11 @@ namespace Unity.Netcode.Transports.UTP
                     }
                     else
                     {
-                        if (String.IsNullOrEmpty(m_ServerCommonName))
+                        if (string.IsNullOrEmpty(m_ServerCommonName))
                         {
                             throw new Exception("In order to use encrypted communications, clients must set the server common name.");
                         }
-                        else if (String.IsNullOrEmpty(m_ClientCaCertificate))
+                        else if (string.IsNullOrEmpty(m_ClientCaCertificate))
                         {
                             m_NetworkSettings.WithSecureClientParameters(m_ServerCommonName);
                         }

Runtime/com.unity.netcode.runtime.asmdef

@@ -12,7 +12,8 @@
         "Unity.Multiplayer.Tools.NetworkSolutionInterface",
         "Unity.Networking.Transport",
         "Unity.Collections",
-        "Unity.Burst"
+        "Unity.Burst",
+        "Unity.Mathematics"
     ],
     "allowUnsafeCode": true,
     "versionDefines": [

TestHelpers/Runtime/AssemblyInfo.cs

@@ -1,6 +1,12 @@
 using System.Runtime.CompilerServices;
 
-[assembly: InternalsVisibleTo("TestProject.EditorTests")]
+#if UNITY_INCLUDE_TESTS
-[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
-[assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")]
 [assembly: InternalsVisibleTo("Unity.Netcode.RuntimeTests")]
+[assembly: InternalsVisibleTo("TestProject.RuntimeTests")]
+#if UNITY_EDITOR
+[assembly: InternalsVisibleTo("TestProject.EditorTests")]
+#endif // UNITY_EDITOR
+#if MULTIPLAYER_TOOLS
+[assembly: InternalsVisibleTo("TestProject.ToolsIntegration.RuntimeTests")]
+#endif // MULTIPLAYER_TOOLS
+#endif // UNITY_INCLUDE_TESTS

TestHelpers/Runtime/IntegrationTestSceneHandler.cs

@@ -15,6 +15,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
     /// </summary>
     internal class IntegrationTestSceneHandler : ISceneManagerHandler, IDisposable
     {
+        private Scene m_InvalidScene = new Scene();
+
+        internal struct SceneEntry
+        {
+            public bool IsAssigned;
+            public Scene Scene;
+        }
+
+        internal static Dictionary<NetworkManager, Dictionary<string, Dictionary<int, SceneEntry>>> SceneNameToSceneHandles = new Dictionary<NetworkManager, Dictionary<string, Dictionary<int, SceneEntry>>>();
+
         // All IntegrationTestSceneHandler instances register their associated NetworkManager
         internal static List<NetworkManager> NetworkManagers = new List<NetworkManager>();
 
@@ -96,7 +106,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// Processes scene loading jobs
         /// </summary>
         /// <param name="queuedSceneJob">job to process</param>
-        static internal IEnumerator ProcessLoadingSceneJob(QueuedSceneJob queuedSceneJob)
+        internal static IEnumerator ProcessLoadingSceneJob(QueuedSceneJob queuedSceneJob)
         {
             var itegrationTestSceneHandler = queuedSceneJob.IntegrationTestSceneHandler;
             while (!itegrationTestSceneHandler.OnCanClientsLoad())
@@ -170,7 +180,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// Processes scene unloading jobs
         /// </summary>
         /// <param name="queuedSceneJob">job to process</param>
-        static internal IEnumerator ProcessUnloadingSceneJob(QueuedSceneJob queuedSceneJob)
+        internal static IEnumerator ProcessUnloadingSceneJob(QueuedSceneJob queuedSceneJob)
         {
             var itegrationTestSceneHandler = queuedSceneJob.IntegrationTestSceneHandler;
             while (!itegrationTestSceneHandler.OnCanClientsUnload())
@@ -213,7 +223,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// Processes all jobs within the queue.
         /// When all jobs are finished, the coroutine stops.
         /// </summary>
-        static internal IEnumerator JobQueueProcessor()
+        internal static IEnumerator JobQueueProcessor()
         {
             while (QueuedSceneJobs.Count != 0)
             {
@@ -267,8 +277,8 @@ namespace Unity.Netcode.TestHelpers.Runtime
         {
             if (m_ServerSceneBeingLoaded == scene.name)
             {
-                ProcessInSceneObjects(scene, NetworkManager);
                 SceneManager.sceneLoaded -= Sever_SceneLoaded;
+                ProcessInSceneObjects(scene, NetworkManager);
             }
         }
 
@@ -330,6 +340,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
                         {
                             continue;
                         }
+
                         if (networkManager.SceneManager.ScenesLoaded.ContainsKey(sceneLoaded.handle))
                         {
                             if (NetworkManager.LogLevel == LogLevel.Developer)
@@ -347,7 +358,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
                         {
                             NetworkLog.LogInfo($"{NetworkManager.name} adding {sceneLoaded.name} with a handle of {sceneLoaded.handle} to its ScenesLoaded.");
                         }
+                        if (DoesANetworkManagerHoldThisScene(sceneLoaded))
+                        {
+                            continue;
+                        }
                         NetworkManager.SceneManager.ScenesLoaded.Add(sceneLoaded.handle, sceneLoaded);
+                        StartTrackingScene(sceneLoaded, true, NetworkManager);
                         return sceneLoaded;
                     }
                 }
@@ -365,6 +381,521 @@ namespace Unity.Netcode.TestHelpers.Runtime
             return true;
         }
 
+        public void ClearSceneTracking(NetworkManager networkManager)
+        {
+            SceneNameToSceneHandles.Clear();
+        }
+
+        public void StopTrackingScene(int handle, string name, NetworkManager networkManager)
+        {
+            if (!SceneNameToSceneHandles.ContainsKey(networkManager))
+            {
+                return;
+            }
+
+            if (SceneNameToSceneHandles[networkManager].ContainsKey(name))
+            {
+                if (SceneNameToSceneHandles[networkManager][name].ContainsKey(handle))
+                {
+                    SceneNameToSceneHandles[networkManager][name].Remove(handle);
+                    if (SceneNameToSceneHandles[networkManager][name].Count == 0)
+                    {
+                        SceneNameToSceneHandles[networkManager].Remove(name);
+                    }
+                }
+            }
+        }
+
+        public void StartTrackingScene(Scene scene, bool assigned, NetworkManager networkManager)
+        {
+            if (!SceneNameToSceneHandles.ContainsKey(networkManager))
+            {
+                SceneNameToSceneHandles.Add(networkManager, new Dictionary<string, Dictionary<int, SceneEntry>>());
+            }
+
+            if (!SceneNameToSceneHandles[networkManager].ContainsKey(scene.name))
+            {
+                SceneNameToSceneHandles[networkManager].Add(scene.name, new Dictionary<int, SceneEntry>());
+            }
+
+            if (!SceneNameToSceneHandles[networkManager][scene.name].ContainsKey(scene.handle))
+            {
+                var sceneEntry = new SceneEntry()
+                {
+                    IsAssigned = true,
+                    Scene = scene
+                };
+                SceneNameToSceneHandles[networkManager][scene.name].Add(scene.handle, sceneEntry);
+            }
+        }
+
+        private bool DoesANetworkManagerHoldThisScene(Scene scene)
+        {
+            foreach (var netManEntry in SceneNameToSceneHandles)
+            {
+                if (!netManEntry.Value.ContainsKey(scene.name))
+                {
+                    continue;
+                }
+                // The other NetworkManager only has to have an entry to
+                // disqualify this scene instance
+                if (netManEntry.Value[scene.name].ContainsKey(scene.handle))
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        public bool DoesSceneHaveUnassignedEntry(string sceneName, NetworkManager networkManager)
+        {
+            var scenesWithSceneName = new List<Scene>();
+            var scenesAssigned = new List<Scene>();
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                if (scene.name == sceneName)
+                {
+                    scenesWithSceneName.Add(scene);
+                }
+            }
+
+            // Check for other NetworkManager instances already having been assigned this scene
+            foreach (var netManEntry in SceneNameToSceneHandles)
+            {
+                // Ignore this NetworkManager instance at this stage
+                if (netManEntry.Key == networkManager)
+                {
+                    continue;
+                }
+
+                foreach (var scene in scenesWithSceneName)
+                {
+                    if (!netManEntry.Value.ContainsKey(scene.name))
+                    {
+                        continue;
+                    }
+                    // The other NetworkManager only has to have an entry to
+                    // disqualify this scene instance
+                    if (netManEntry.Value[scene.name].ContainsKey(scene.handle))
+                    {
+                        scenesAssigned.Add(scene);
+                    }
+                }
+            }
+
+            // Remove all of the assigned scenes from the list of scenes with the
+            // passed in scene name.
+            foreach (var assignedScene in scenesAssigned)
+            {
+                if (scenesWithSceneName.Contains(assignedScene))
+                {
+                    scenesWithSceneName.Remove(assignedScene);
+                }
+            }
+
+            // If all currently loaded scenes with the scene name are taken
+            // then we return false
+            if (scenesWithSceneName.Count == 0)
+            {
+                return false;
+            }
+
+            // If we made it here, then no other NetworkManager is tracking this scene
+            // and if we don't have an entry for this NetworkManager then we can use any
+            // of the remaining scenes loaded with that name.
+            if (!SceneNameToSceneHandles.ContainsKey(networkManager))
+            {
+                return true;
+            }
+
+            // If we don't yet have a scene name in this NetworkManager's lookup table,
+            // then we can use any of the remaining availabel scenes with that scene name
+            if (!SceneNameToSceneHandles[networkManager].ContainsKey(sceneName))
+            {
+                return true;
+            }
+
+            foreach (var scene in scenesWithSceneName)
+            {
+                // If we don't have an entry for this scene handle (with the scene name) then we
+                // can use that scene
+                if (!SceneNameToSceneHandles[networkManager][scene.name].ContainsKey(scene.handle))
+                {
+                    return true;
+                }
+
+                // This entry is not assigned, then we can use the associated scene
+                if (!SceneNameToSceneHandles[networkManager][scene.name][scene.handle].IsAssigned)
+                {
+                    return true;
+                }
+            }
+
+            // None of the scenes with the same scene name can be used
+            return false;
+        }
+
+        public Scene GetSceneFromLoadedScenes(string sceneName, NetworkManager networkManager)
+        {
+
+            if (!SceneNameToSceneHandles.ContainsKey(networkManager))
+            {
+                return m_InvalidScene;
+            }
+            if (SceneNameToSceneHandles[networkManager].ContainsKey(sceneName))
+            {
+                foreach (var sceneHandleEntry in SceneNameToSceneHandles[networkManager][sceneName])
+                {
+                    if (!sceneHandleEntry.Value.IsAssigned)
+                    {
+                        var sceneEntry = sceneHandleEntry.Value;
+                        sceneEntry.IsAssigned = true;
+                        SceneNameToSceneHandles[networkManager][sceneName][sceneHandleEntry.Key] = sceneEntry;
+                        return sceneEntry.Scene;
+                    }
+                }
+            }
+            // This is tricky since NetworkManager instances share the same scene hierarchy during integration tests.
+            // TODO 2023: Determine if there is a better way to associate the active scene for client NetworkManager instances.
+            var activeScene = SceneManager.GetActiveScene();
+
+            if (sceneName == activeScene.name && networkManager.SceneManager.ClientSynchronizationMode == LoadSceneMode.Additive)
+            {
+                // For now, just return the current active scene
+                // Note: Clients will not be able to synchronize in-scene placed NetworkObjects in an integration test for
+                // scenes loaded that have in-scene placed NetworkObjects prior to the clients joining (i.e. there will only
+                // ever be one instance of the active scene). To test in-scene placed NetworkObjects and make an integration
+                // test loaded scene be the active scene, don't set scene as an active scene on the server side until all
+                // clients have connected and loaded the scene.
+                return activeScene;
+            }
+            // If we found nothing return an invalid scene
+            return m_InvalidScene;
+        }
+
+        public void PopulateLoadedScenes(ref Dictionary<int, Scene> scenesLoaded, NetworkManager networkManager)
+        {
+            if (!SceneNameToSceneHandles.ContainsKey(networkManager))
+            {
+                SceneNameToSceneHandles.Add(networkManager, new Dictionary<string, Dictionary<int, SceneEntry>>());
+            }
+
+            var sceneCount = SceneManager.sceneCount;
+            for (int i = 0; i < sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                // Ignore scenes that belong to other NetworkManager instances
+
+                if (DoesANetworkManagerHoldThisScene(scene))
+                {
+                    continue;
+                }
+
+                if (!DoesSceneHaveUnassignedEntry(scene.name, networkManager))
+                {
+                    continue;
+                }
+
+                if (!SceneNameToSceneHandles[networkManager].ContainsKey(scene.name))
+                {
+                    SceneNameToSceneHandles[networkManager].Add(scene.name, new Dictionary<int, SceneEntry>());
+                }
+
+                if (!SceneNameToSceneHandles[networkManager][scene.name].ContainsKey(scene.handle))
+                {
+                    var sceneEntry = new SceneEntry()
+                    {
+                        IsAssigned = false,
+                        Scene = scene
+                    };
+                    SceneNameToSceneHandles[networkManager][scene.name].Add(scene.handle, sceneEntry);
+                    if (!scenesLoaded.ContainsKey(scene.handle))
+                    {
+                        scenesLoaded.Add(scene.handle, scene);
+                    }
+                }
+                else
+                {
+                    throw new Exception($"[{networkManager.LocalClient.PlayerObject.name}][Duplicate Handle] Scene {scene.name} already has scene handle {scene.handle} registered!");
+                }
+            }
+        }
+
+        private Dictionary<Scene, NetworkManager> m_ScenesToUnload = new Dictionary<Scene, NetworkManager>();
+
+        /// <summary>
+        /// Handles unloading any scenes that might remain on a client that
+        /// need to be unloaded.
+        /// </summary>
+        /// <param name="networkManager"></param>
+        public void UnloadUnassignedScenes(NetworkManager networkManager = null)
+        {
+            if (!SceneNameToSceneHandles.ContainsKey(networkManager))
+            {
+                return;
+            }
+            var relativeSceneNameToSceneHandles = SceneNameToSceneHandles[networkManager];
+            var sceneManager = networkManager.SceneManager;
+            SceneManager.sceneUnloaded += SceneManager_SceneUnloaded;
+
+            foreach (var sceneEntry in relativeSceneNameToSceneHandles)
+            {
+                var scenHandleEntries = relativeSceneNameToSceneHandles[sceneEntry.Key];
+                foreach (var sceneHandleEntry in scenHandleEntries)
+                {
+                    if (!sceneHandleEntry.Value.IsAssigned)
+                    {
+                        if (sceneManager.VerifySceneBeforeUnloading == null || sceneManager.VerifySceneBeforeUnloading.Invoke(sceneHandleEntry.Value.Scene))
+                        {
+                            m_ScenesToUnload.Add(sceneHandleEntry.Value.Scene, networkManager);
+                        }
+                    }
+                }
+            }
+
+            foreach (var sceneToUnload in m_ScenesToUnload)
+            {
+                SceneManager.UnloadSceneAsync(sceneToUnload.Key);
+            }
+        }
+
+        /// <summary>
+        /// Removes the scene entry from the scene name to scene handle table
+        /// </summary>
+        private void SceneManager_SceneUnloaded(Scene scene)
+        {
+            if (m_ScenesToUnload.ContainsKey(scene))
+            {
+                var networkManager = m_ScenesToUnload[scene];
+                var relativeSceneNameToSceneHandles = SceneNameToSceneHandles[networkManager];
+                if (relativeSceneNameToSceneHandles.ContainsKey(scene.name))
+                {
+                    var scenHandleEntries = relativeSceneNameToSceneHandles[scene.name];
+                    if (scenHandleEntries.ContainsKey(scene.handle))
+                    {
+                        scenHandleEntries.Remove(scene.handle);
+                        if (scenHandleEntries.Count == 0)
+                        {
+                            relativeSceneNameToSceneHandles.Remove(scene.name);
+                        }
+                        m_ScenesToUnload.Remove(scene);
+                        if (m_ScenesToUnload.Count == 0)
+                        {
+                            SceneManager.sceneUnloaded -= SceneManager_SceneUnloaded;
+                        }
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Integration test version that handles migrating dynamically spawned NetworkObjects to
+        /// the DDOL when a scene is unloaded
+        /// </summary>
+        /// <param name="networkManager"><see cref="NetworkManager"/> relative instance</param>
+        /// <param name="scene">scene being unloaded</param>
+        public void MoveObjectsFromSceneToDontDestroyOnLoad(ref NetworkManager networkManager, Scene scene)
+        {
+            // Create a local copy of the spawned objects list since the spawn manager will adjust the list as objects
+            // are despawned.
+#if UNITY_2023_1_OR_NEWER
+            var networkObjects = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.InstanceID).Where((c) => c.IsSpawned);
+#else
+            var networkObjects = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsSpawned);
+#endif
+            foreach (var networkObject in networkObjects)
+            {
+                if (networkObject == null || (networkObject != null && networkObject.gameObject.scene.handle != scene.handle))
+                {
+                    if (networkObject != null)
+                    {
+                        VerboseDebug($"[MoveObjects from {scene.name} | {scene.handle}] Ignoring {networkObject.gameObject.name} because it isn't in scene {networkObject.gameObject.scene.name} ");
+                    }
+                    continue;
+                }
+
+                bool skipPrefab = false;
+
+                foreach (var networkPrefab in networkManager.NetworkConfig.Prefabs.Prefabs)
+                {
+                    if (networkPrefab.Prefab == null)
+                    {
+                        continue;
+                    }
+                    if (networkObject == networkPrefab.Prefab.GetComponent<NetworkObject>())
+                    {
+                        skipPrefab = true;
+                        break;
+                    }
+                }
+                if (skipPrefab)
+                {
+                    continue;
+                }
+
+                // Only NetworkObjects marked to not be destroyed with the scene and are not already in the DDOL are preserved
+                if (!networkObject.DestroyWithScene && networkObject.gameObject.scene != networkManager.SceneManager.DontDestroyOnLoadScene)
+                {
+                    // Only move dynamically spawned NetworkObjects with no parent as the children will follow
+                    if (networkObject.gameObject.transform.parent == null && networkObject.IsSceneObject != null && !networkObject.IsSceneObject.Value)
+                    {
+                        VerboseDebug($"[MoveObjects from {scene.name} | {scene.handle}] Moving {networkObject.gameObject.name} because it is in scene {networkObject.gameObject.scene.name} with DWS = {networkObject.DestroyWithScene}.");
+                        Object.DontDestroyOnLoad(networkObject.gameObject);
+                    }
+                }
+                else if (networkManager.IsServer)
+                {
+                    if (networkObject.NetworkManager == networkManager)
+                    {
+                        VerboseDebug($"[MoveObjects from {scene.name} | {scene.handle}] Destroying {networkObject.gameObject.name} because it is in scene {networkObject.gameObject.scene.name} with DWS = {networkObject.DestroyWithScene}.");
+                        networkObject.Despawn();
+                    }
+                    else //For integration testing purposes, migrate remaining into DDOL
+                    {
+                        VerboseDebug($"[MoveObjects from {scene.name} | {scene.handle}] Temporarily migrating {networkObject.gameObject.name} into DDOL to await server destroy message.");
+                        Object.DontDestroyOnLoad(networkObject.gameObject);
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Sets the client synchronization mode which impacts whether both the server or client take into consideration scenes loaded before
+        /// starting the <see cref="NetworkManager"/>.
+        /// </summary>
+        /// <remarks>
+        /// <see cref="LoadSceneMode.Single"/>: Does not take preloaded scenes into consideration
+        /// <see cref="LoadSceneMode.Single"/>: Does take preloaded scenes into consideration
+        /// </remarks>
+        /// <param name="networkManager">relative <see cref="NetworkManager"/> instance</param>
+        /// <param name="mode"><see cref="LoadSceneMode.Single"/> or <see cref="LoadSceneMode.Additive"/></param>
+        public void SetClientSynchronizationMode(ref NetworkManager networkManager, LoadSceneMode mode)
+        {
+
+            var sceneManager = networkManager.SceneManager;
+
+            // Don't let client's set this value
+            if (!networkManager.IsServer)
+            {
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                {
+                    NetworkLog.LogWarning("Clients should not set this value as it is automatically synchronized with the server's setting!");
+                }
+                return;
+            }
+            else if (networkManager.ConnectedClientsIds.Count > (networkManager.IsHost ? 1 : 0) && sceneManager.ClientSynchronizationMode != mode)
+            {
+                if (NetworkLog.CurrentLogLevel <= LogLevel.Normal)
+                {
+                    NetworkLog.LogWarning("Server is changing client synchronization mode after clients have been synchronized! It is recommended to do this before clients are connected!");
+                }
+            }
+
+
+
+            // For additive client synchronization, we take into consideration scenes
+            // already loaded.
+            if (mode == LoadSceneMode.Additive)
+            {
+                if (networkManager.IsServer)
+                {
+                    sceneManager.OnSceneEvent -= SceneManager_OnSceneEvent;
+                    sceneManager.OnSceneEvent += SceneManager_OnSceneEvent;
+                }
+
+                if (!SceneNameToSceneHandles.ContainsKey(networkManager))
+                {
+                    SceneNameToSceneHandles.Add(networkManager, new Dictionary<string, Dictionary<int, SceneEntry>>());
+                }
+
+                var networkManagerScenes = SceneNameToSceneHandles[networkManager];
+
+                for (int i = 0; i < SceneManager.sceneCount; i++)
+                {
+                    var scene = SceneManager.GetSceneAt(i);
+
+                    // Ignore scenes that belong to other NetworkManager instances
+                    if (!DoesSceneHaveUnassignedEntry(scene.name, networkManager))
+                    {
+                        continue;
+                    }
+
+                    // If using scene verification
+                    if (sceneManager.VerifySceneBeforeLoading != null)
+                    {
+                        // Determine if we should take this scene into consideration
+                        if (!sceneManager.VerifySceneBeforeLoading.Invoke(scene.buildIndex, scene.name, LoadSceneMode.Additive))
+                        {
+                            continue;
+                        }
+                    }
+
+                    // If the scene is not already in the ScenesLoaded list, then add it
+                    if (!sceneManager.ScenesLoaded.ContainsKey(scene.handle))
+                    {
+                        StartTrackingScene(scene, true, networkManager);
+                        sceneManager.ScenesLoaded.Add(scene.handle, scene);
+                    }
+                }
+            }
+            // Set the client synchronization mode
+            sceneManager.ClientSynchronizationMode = mode;
+        }
+
+        /// <summary>
+        /// During integration testing, if the server loads a scene then
+        /// we want to start tracking it.
+        /// </summary>
+        /// <param name="sceneEvent"></param>
+        private void SceneManager_OnSceneEvent(SceneEvent sceneEvent)
+        {
+            // Filter for server only scene events
+            if (!NetworkManager.IsServer || sceneEvent.ClientId != NetworkManager.ServerClientId)
+            {
+                return;
+            }
+
+            switch (sceneEvent.SceneEventType)
+            {
+                case SceneEventType.LoadComplete:
+                    {
+                        StartTrackingScene(sceneEvent.Scene, true, NetworkManager);
+                        break;
+                    }
+            }
+        }
+
+        /// <summary>
+        /// Handles determining if a client should attempt to load a scene during synchronization.
+        /// </summary>
+        /// <param name="sceneName">name of the scene to be loaded</param>
+        /// <param name="isPrimaryScene">when in client synchronization mode single, this determines if the scene is the primary active scene</param>
+        /// <param name="clientSynchronizationMode">the current client synchronization mode</param>
+        /// <param name="networkManager"><see cref="NetworkManager"/>relative instance</param>
+        /// <returns></returns>
+        public bool ClientShouldPassThrough(string sceneName, bool isPrimaryScene, LoadSceneMode clientSynchronizationMode, NetworkManager networkManager)
+        {
+            var shouldPassThrough = clientSynchronizationMode == LoadSceneMode.Single ? false : DoesSceneHaveUnassignedEntry(sceneName, networkManager);
+            var activeScene = SceneManager.GetActiveScene();
+
+            // If shouldPassThrough is not yet true and the scene to be loaded is the currently active scene
+            if (!shouldPassThrough && sceneName == activeScene.name)
+            {
+                // In additive client synchronization mode we always pass through.
+                // Unlike the default behavior(i.e. DefaultSceneManagerHandler), for integration testing we always return false
+                // if it is the active scene and the client synchronization mode is LoadSceneMode.Single because the client should
+                // load the active scene additively for this NetworkManager instance (i.e. can't have multiple active scenes).
+                if (clientSynchronizationMode == LoadSceneMode.Additive)
+                {
+                    // don't try to reload this scene and pass through to post load processing.
+                    shouldPassThrough = true;
+                }
+            }
+            return shouldPassThrough;
+        }
+
         /// <summary>
         /// Constructor now must take NetworkManager
         /// </summary>
@@ -410,7 +941,11 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 }
             }
             QueuedSceneJobs.Clear();
-            Object.Destroy(CoroutineRunner.gameObject);
+            if (CoroutineRunner != null && CoroutineRunner.gameObject != null)
+            {
+                Object.Destroy(CoroutineRunner.gameObject);
+            }
+
         }
     }
 }

TestHelpers/Runtime/IntegrationTestWithApproximation.cs

@@ -0,0 +1,79 @@
+using System.Runtime.CompilerServices;
+using UnityEngine;
+
+
+namespace Unity.Netcode.TestHelpers.Runtime
+{
+    public abstract class IntegrationTestWithApproximation : NetcodeIntegrationTest
+    {
+        private const float k_AproximateDeltaVariance = 0.01f;
+
+        protected virtual float GetDeltaVarianceThreshold()
+        {
+            return k_AproximateDeltaVariance;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected float EulerDelta(float a, float b)
+        {
+            return Mathf.DeltaAngle(a, b);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected Vector3 EulerDelta(Vector3 a, Vector3 b)
+        {
+            return new Vector3(Mathf.DeltaAngle(a.x, b.x), Mathf.DeltaAngle(a.y, b.y), Mathf.DeltaAngle(a.z, b.z));
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected bool ApproximatelyEuler(float a, float b)
+        {
+            return Mathf.Abs(EulerDelta(a, b)) <= GetDeltaVarianceThreshold();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected bool Approximately(float a, float b)
+        {
+            return Mathf.Abs(a - b) <= GetDeltaVarianceThreshold();
+        }
+
+        protected bool Approximately(Vector2 a, Vector2 b)
+        {
+            var deltaVariance = GetDeltaVarianceThreshold();
+            return Mathf.Abs(a.x - b.x) <= deltaVariance &&
+                Mathf.Abs(a.y - b.y) <= deltaVariance;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected bool Approximately(Vector3 a, Vector3 b)
+        {
+            var deltaVariance = GetDeltaVarianceThreshold();
+            return Mathf.Abs(a.x - b.x) <= deltaVariance &&
+                Mathf.Abs(a.y - b.y) <= deltaVariance &&
+                Mathf.Abs(a.z - b.z) <= deltaVariance;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected bool Approximately(Quaternion a, Quaternion b)
+        {
+            var deltaVariance = GetDeltaVarianceThreshold();
+            return Mathf.Abs(a.x - b.x) <= deltaVariance &&
+                Mathf.Abs(a.y - b.y) <= deltaVariance &&
+                Mathf.Abs(a.z - b.z) <= deltaVariance &&
+                Mathf.Abs(a.w - b.w) <= deltaVariance;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected bool ApproximatelyEuler(Vector3 a, Vector3 b)
+        {
+            return ApproximatelyEuler(a.x, b.x) && ApproximatelyEuler(a.y, b.y) && ApproximatelyEuler(a.z, b.z);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected Vector3 GetRandomVector3(float min, float max)
+        {
+            return new Vector3(Random.Range(min, max), Random.Range(min, max), Random.Range(min, max));
+        }
+
+    }
+}

TestHelpers/Runtime/IntegrationTestWithApproximation.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 50a3b194bb5b8714d883dafd911db1ba
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

TestHelpers/Runtime/MockTimeProvider.cs

@@ -0,0 +1,30 @@
+namespace Unity.Netcode.TestHelpers.Runtime
+{
+    public class MockTimeProvider : IRealTimeProvider
+    {
+        public float RealTimeSinceStartup => (float)s_DoubleRealTime;
+        public float UnscaledTime => (float)s_DoubleRealTime;
+        public float UnscaledDeltaTime => (float)s_DoubleDelta;
+        public float DeltaTime => (float)s_DoubleDelta;
+
+        public static float StaticRealTimeSinceStartup => (float)s_DoubleRealTime;
+        public static float StaticUnscaledTime => (float)s_DoubleRealTime;
+        public static float StaticUnscaledDeltaTime => (float)s_DoubleDelta;
+        public static float StaticDeltaTime => (float)s_DoubleDelta;
+
+        private static double s_DoubleRealTime = 0;
+        private static double s_DoubleDelta = 0;
+
+        public static void TimeTravel(double amountOfTimeTraveled)
+        {
+            s_DoubleDelta = amountOfTimeTraveled;
+            s_DoubleRealTime += amountOfTimeTraveled;
+        }
+
+        public static void Reset()
+        {
+            s_DoubleDelta = 0;
+            s_DoubleRealTime = 0;
+        }
+    }
+}

TestHelpers/Runtime/MockTimeProvider.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bcc9a7faadea4b8ebeb041ee6e395a92
+timeCreated: 1679414015

TestHelpers/Runtime/MockTransport.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+
+namespace Unity.Netcode.TestHelpers.Runtime
+{
+    internal class MockTransport : NetworkTransport
+    {
+        private struct MessageData
+        {
+            public ulong FromClientId;
+            public ArraySegment<byte> Payload;
+            public NetworkEvent Event;
+        }
+
+        private static Dictionary<ulong, Queue<MessageData>> s_MessageQueue = new Dictionary<ulong, Queue<MessageData>>();
+
+        public override ulong ServerClientId { get; } = 0;
+
+        public static ulong HighTransportId = 0;
+        public ulong TransportId = 0;
+
+        public NetworkManager NetworkManager;
+
+        public override void Send(ulong clientId, ArraySegment<byte> payload, NetworkDelivery networkDelivery)
+        {
+            var copy = new byte[payload.Array.Length];
+            Array.Copy(payload.Array, copy, payload.Array.Length);
+            s_MessageQueue[clientId].Enqueue(new MessageData { FromClientId = TransportId, Payload = new ArraySegment<byte>(copy, payload.Offset, payload.Count), Event = NetworkEvent.Data });
+        }
+
+        public override NetworkEvent PollEvent(out ulong clientId, out ArraySegment<byte> payload, out float receiveTime)
+        {
+            if (s_MessageQueue[TransportId].Count > 0)
+            {
+                var data = s_MessageQueue[TransportId].Dequeue();
+                clientId = data.FromClientId;
+                payload = data.Payload;
+                receiveTime = NetworkManager.RealTimeProvider.RealTimeSinceStartup;
+                if (NetworkManager.IsServer && data.Event == NetworkEvent.Connect)
+                {
+                    s_MessageQueue[data.FromClientId].Enqueue(new MessageData { Event = NetworkEvent.Connect, FromClientId = ServerClientId, Payload = new ArraySegment<byte>() });
+                }
+                return data.Event;
+            }
+            clientId = 0;
+            payload = new ArraySegment<byte>();
+            receiveTime = 0;
+            return NetworkEvent.Nothing;
+        }
+
+        public override bool StartClient()
+        {
+            TransportId = ++HighTransportId;
+            s_MessageQueue[TransportId] = new Queue<MessageData>();
+            s_MessageQueue[ServerClientId].Enqueue(new MessageData { Event = NetworkEvent.Connect, FromClientId = TransportId, Payload = new ArraySegment<byte>() });
+            return true;
+        }
+
+        public override bool StartServer()
+        {
+            s_MessageQueue[ServerClientId] = new Queue<MessageData>();
+            return true;
+        }
+
+        public override void DisconnectRemoteClient(ulong clientId)
+        {
+            s_MessageQueue[clientId].Enqueue(new MessageData { Event = NetworkEvent.Disconnect, FromClientId = TransportId, Payload = new ArraySegment<byte>() });
+        }
+
+        public override void DisconnectLocalClient()
+        {
+            s_MessageQueue[ServerClientId].Enqueue(new MessageData { Event = NetworkEvent.Disconnect, FromClientId = TransportId, Payload = new ArraySegment<byte>() });
+        }
+
+        public override ulong GetCurrentRtt(ulong clientId)
+        {
+            return 0;
+        }
+
+        public override void Shutdown()
+        {
+        }
+
+        public override void Initialize(NetworkManager networkManager = null)
+        {
+            NetworkManager = networkManager;
+        }
+    }
+}

TestHelpers/Runtime/MockTransport.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 335908e9a37f428ba087acf00563c7be
+timeCreated: 1679415868

TestHelpers/Runtime/NetcodeIntegrationTest.cs

@@ -2,12 +2,14 @@ using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
 using NUnit.Framework;
+using Unity.Netcode.RuntimeTests;
+using Unity.Netcode.Transports.UTP;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 using UnityEngine.TestTools;
-using System.Runtime.CompilerServices;
-using Unity.Netcode.RuntimeTests;
 using Object = UnityEngine.Object;
 
 namespace Unity.Netcode.TestHelpers.Runtime
@@ -22,6 +24,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// determine how clients will load scenes
         /// </summary>
         internal static bool IsRunning { get; private set; }
+
         protected static TimeoutHelper s_GlobalTimeoutHelper = new TimeoutHelper(8.0f);
         protected static WaitForSecondsRealtime s_DefaultWaitForTick = new WaitForSecondsRealtime(1.0f / k_DefaultTickRate);
 
@@ -44,6 +47,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             {
                 s_GlobalNetworkObjects.Add(networkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
             }
+
             if (s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId].ContainsKey(networkObject.NetworkObjectId))
             {
                 if (s_GlobalNetworkObjects[networkObject.NetworkManager.LocalClientId] == null)
@@ -100,9 +104,9 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
         public enum NetworkManagerInstatiationMode
         {
-            PerTest,        // This will create and destroy new NetworkManagers for each test within a child derived class
+            PerTest, // This will create and destroy new NetworkManagers for each test within a child derived class
-            AllTests,       // This will create one set of NetworkManagers used for all tests within a child derived class (destroyed once all tests are finished)
+            AllTests, // This will create one set of NetworkManagers used for all tests within a child derived class (destroyed once all tests are finished)
-            DoNotCreate     // This will not create any NetworkManagers, it is up to the derived class to manage.
+            DoNotCreate // This will not create any NetworkManagers, it is up to the derived class to manage.
         }
 
         public enum HostOrServer
@@ -143,6 +147,75 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </remarks>
         protected bool m_BypassConnectionTimeout { get; set; }
 
+        /// <summary>
+        /// Enables "Time Travel" within the test, which swaps the time provider for the SDK from Unity's
+        /// <see cref="Time"/> class to <see cref="MockTimeProvider"/>, and also swaps the transport implementation
+        /// from <see cref="UnityTransport"/> to <see cref="MockTransport"/>.
+        ///
+        /// This enables five important things that help with both performance and determinism of tests that involve a
+        /// lot of time and waiting:
+        /// 1) It allows time to move in a completely deterministic way (testing that something happens after n seconds,
+        /// the test will always move exactly n seconds with no chance of any variability in the timing),
+        /// 2) It allows skipping periods of time without actually waiting that amount of time, while still simulating
+        /// SDK frames as if that time were passing,
+        /// 3) It dissociates the SDK's update loop from Unity's update loop, allowing us to simulate SDK frame updates
+        /// without waiting for Unity to process things like physics, animation, and rendering that aren't relevant to
+        /// the test,
+        /// 4) It dissociates the SDK's messaging system from the networking hardware, meaning there's no delay between
+        /// a message being sent and it being received, allowing us to deterministically rely on the message being
+        /// received within specific time frames for the test, and
+        /// 5) It allows tests to be written without the use of coroutines, which not only improves the test's runtime,
+        /// but also results in easier-to-read callstacks and removes the possibility for an assertion to result in the
+        /// test hanging.
+        ///
+        /// When time travel is enabled, the following methods become available:
+        ///
+        /// <see cref="TimeTravel"/>: Simulates a specific number of frames passing over a specific time period
+        /// <see cref="TimeTravelToNextTick"/>: Skips forward to the next tick, siumlating at the current application frame rate
+        /// <see cref="WaitForConditionOrTimeOutWithTimeTravel(Func{bool},int)"/>: Simulates frames at the application frame rate until the given condition is true
+        /// <see cref="WaitForMessageReceivedWithTimeTravel{T}"/>: Simulates frames at the application frame rate until the required message is received
+        /// <see cref="WaitForMessagesReceivedWithTimeTravel"/>: Simulates frames at the application frame rate until the required messages are received
+        /// <see cref="StartServerAndClientsWithTimeTravel"/>: Starts a server and client and allows them to connect via simulated frames
+        /// <see cref="CreateAndStartNewClientWithTimeTravel"/>: Creates a client and waits for it to connect via simulated frames
+        /// <see cref="WaitForClientsConnectedOrTimeOutWithTimeTravel(Unity.Netcode.NetworkManager[])"/> Simulates frames at the application frame rate until the given clients are connected
+        /// <see cref="StopOneClientWithTimeTravel"/>: Stops a client and simulates frames until it's fully disconnected.
+        ///
+        /// When time travel is enabled, <see cref="NetcodeIntegrationTest"/> will automatically use these in its methods
+        /// when doing things like automatically connecting clients during SetUp.
+        ///
+        /// Additionally, the following methods replace their non-time-travel equivalents with variants that are not coroutines:
+        /// <see cref="OnTimeTravelStartedServerAndClients"/> - called when server and clients are started
+        /// <see cref="OnTimeTravelServerAndClientsConnected"/> - called when server and clients are connected
+        ///
+        /// Note that all of the non-time travel functions can still be used even when time travel is enabled - this is
+        /// sometimes needed for, e.g., testing NetworkAnimator, where the unity update loop needs to run to process animations.
+        /// However, it's VERY important to note here that, because the SDK will not be operating based on real-world time
+        /// but based on the frozen time that's locked in from MockTimeProvider, actions that pass 10 seconds apart by
+        /// real-world clock time will be perceived by the SDK as having happened simultaneously if you don't call
+        /// <see cref="MockTimeProvider.TimeTravel"/> to cover the equivalent time span in the mock time provider.
+        /// (Calling <see cref="MockTimeProvider.TimeTravel"/> instead of <see cref="TimeTravel"/>
+        /// will move time forward without simulating any frames, which, in the case where real-world time has passed,
+        /// is likely more desirable). In most cases, this desynch won't affect anything, but it is worth noting that
+        /// it happens just in case a tested system depends on both the unity update loop happening *and* time moving forward.
+        /// </summary>
+        protected virtual bool m_EnableTimeTravel => false;
+
+        /// <summary>
+        /// If this is false, SetUp will call OnInlineSetUp instead of OnSetUp.
+        /// This is a performance advantage when not using the coroutine functionality, as a coroutine that
+        /// has no yield instructions in it will nonetheless still result in delaying the continuation of the
+        /// method that called it for a full frame after it returns.
+        /// </summary>
+        protected virtual bool m_SetupIsACoroutine => true;
+
+        /// <summary>
+        /// If this is false, TearDown will call OnInlineTearDown instead of OnTearDown.
+        /// This is a performance advantage when not using the coroutine functionality, as a coroutine that
+        /// has no yield instructions in it will nonetheless still result in delaying the continuation of the
+        /// method that called it for a full frame after it returns.
+        /// </summary>
+        protected virtual bool m_TearDownIsACoroutine => true;
+
         /// <summary>
         /// Used to display the various integration test
         /// stages and can be used to log verbose information
@@ -216,20 +289,54 @@ namespace Unity.Netcode.TestHelpers.Runtime
             yield return null;
         }
 
+        /// <summary>
+        /// Called before creating and starting the server and clients
+        /// Note: For <see cref="NetworkManagerInstatiationMode.AllTests"/> and
+        /// <see cref="NetworkManagerInstatiationMode.PerTest"/> mode integration tests.
+        /// For those two modes, if you want to have access to the server or client
+        /// <see cref="NetworkManager"/>s then override <see cref="OnServerAndClientsCreated"/>.
+        /// <see cref="m_ServerNetworkManager"/> and <see cref="m_ClientNetworkManagers"/>
+        /// </summary>
+        protected virtual void OnInlineSetup()
+        {
+        }
+
         [UnitySetUp]
         public IEnumerator SetUp()
         {
             VerboseDebug($"Entering {nameof(SetUp)}");
 
             NetcodeLogAssert = new NetcodeLogAssert();
-            yield return OnSetup();
+            if (m_SetupIsACoroutine)
+            {
+                yield return OnSetup();
+            }
+            else
+            {
+                OnInlineSetup();
+            }
+
+            if (m_EnableTimeTravel)
+            {
+                MockTimeProvider.Reset();
+                ComponentFactory.Register<IRealTimeProvider>(manager => new MockTimeProvider());
+            }
+
             if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.AllTests && m_ServerNetworkManager == null ||
                 m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.PerTest)
             {
                 CreateServerAndClients();
 
-                yield return StartServerAndClients();
+                if (m_EnableTimeTravel)
+                {
+                    StartServerAndClientsWithTimeTravel();
+                }
+                else
+                {
+                    yield return StartServerAndClients();
+                }
             }
+
             VerboseDebug($"Exiting {nameof(SetUp)}");
         }
 
@@ -241,11 +348,20 @@ namespace Unity.Netcode.TestHelpers.Runtime
         {
         }
 
+        /// <summary>
+        /// Invoked immediately after the player prefab GameObject is created
+        /// prior to adding a NetworkObject component
+        /// </summary>
+        protected virtual void OnPlayerPrefabGameObjectCreated()
+        {
+        }
+
         private void CreatePlayerPrefab()
         {
             VerboseDebug($"Entering {nameof(CreatePlayerPrefab)}");
             // Create playerPrefab
             m_PlayerPrefab = new GameObject("Player");
+            OnPlayerPrefabGameObjectCreated();
             NetworkObject networkObject = m_PlayerPrefab.AddComponent<NetworkObject>();
 
             // Make it a prefab
@@ -285,6 +401,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             {
                 clientNetworkManagersList.Remove(networkManager);
             }
+
             m_ClientNetworkManagers = clientNetworkManagersList.ToArray();
             m_NumberOfClients = clientNetworkManagersList.Count;
         }
@@ -295,7 +412,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </summary>
         protected virtual void OnNewClientCreated(NetworkManager networkManager)
         {
-
         }
 
         /// <summary>
@@ -313,7 +429,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </summary>
         protected virtual void OnNewClientStartedAndConnected(NetworkManager networkManager)
         {
-
         }
 
         /// <summary>
@@ -322,7 +437,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </summary>
         protected IEnumerator CreateAndStartNewClient()
         {
-            var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length);
+            var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);
             networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
 
             // Notification that the new client (NetworkManager) has been created
@@ -347,13 +462,53 @@ namespace Unity.Netcode.TestHelpers.Runtime
             if (s_GlobalTimeoutHelper.TimedOut)
             {
                 AddRemoveNetworkManager(networkManager, false);
-                Object.Destroy(networkManager.gameObject);
+                Object.DestroyImmediate(networkManager.gameObject);
             }
+
             AssertOnTimeout($"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");
             ClientNetworkManagerPostStart(networkManager);
             VerboseDebug($"[{networkManager.name}] Created and connected!");
         }
 
+        /// <summary>
+        /// This will create, start, and connect a new client while in the middle of an
+        /// integration test.
+        /// </summary>
+        protected void CreateAndStartNewClientWithTimeTravel()
+        {
+            var networkManager = NetcodeIntegrationTestHelpers.CreateNewClient(m_ClientNetworkManagers.Length, m_EnableTimeTravel);
+            networkManager.NetworkConfig.PlayerPrefab = m_PlayerPrefab;
+
+            // Notification that the new client (NetworkManager) has been created
+            // in the event any modifications need to be made before starting the client
+            OnNewClientCreated(networkManager);
+
+            NetcodeIntegrationTestHelpers.StartOneClient(networkManager);
+
+            if (LogAllMessages)
+            {
+                networkManager.MessagingSystem.Hook(new DebugNetworkHooks());
+            }
+
+            AddRemoveNetworkManager(networkManager, true);
+
+            OnNewClientStarted(networkManager);
+
+            // Wait for the new client to connect
+            var connected = WaitForClientsConnectedOrTimeOutWithTimeTravel();
+
+            OnNewClientStartedAndConnected(networkManager);
+            if (!connected)
+            {
+                AddRemoveNetworkManager(networkManager, false);
+                Object.DestroyImmediate(networkManager.gameObject);
+            }
+
+            Assert.IsTrue(connected, $"{nameof(CreateAndStartNewClient)} timed out waiting for the new client to be connected!");
+            ClientNetworkManagerPostStart(networkManager);
+            VerboseDebug($"[{networkManager.name}] Created and connected!");
+        }
+
         /// <summary>
         /// This will stop a client while in the middle of an integration test
         /// </summary>
@@ -364,6 +519,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
             yield return WaitForConditionOrTimeOut(() => !networkManager.IsConnectedClient);
         }
 
+        /// <summary>
+        /// This will stop a client while in the middle of an integration test
+        /// </summary>
+        protected void StopOneClientWithTimeTravel(NetworkManager networkManager, bool destroy = false)
+        {
+            NetcodeIntegrationTestHelpers.StopOneClient(networkManager, destroy);
+            AddRemoveNetworkManager(networkManager, false);
+            Assert.True(WaitForConditionOrTimeOutWithTimeTravel(() => !networkManager.IsConnectedClient));
+        }
+
         /// <summary>
         /// Creates the server and clients
         /// </summary>
@@ -374,8 +539,13 @@ namespace Unity.Netcode.TestHelpers.Runtime
 
             CreatePlayerPrefab();
 
+            if (m_EnableTimeTravel)
+            {
+                m_TargetFrameRate = -1;
+            }
+
             // Create multiple NetworkManager instances
-            if (!NetcodeIntegrationTestHelpers.Create(numberOfClients, out NetworkManager server, out NetworkManager[] clients, m_TargetFrameRate, m_CreateServerFirst))
+            if (!NetcodeIntegrationTestHelpers.Create(numberOfClients, out NetworkManager server, out NetworkManager[] clients, m_TargetFrameRate, m_CreateServerFirst, m_EnableTimeTravel))
             {
                 Debug.LogError("Failed to create instances");
                 Assert.Fail("Failed to create instances");
@@ -422,6 +592,14 @@ namespace Unity.Netcode.TestHelpers.Runtime
             yield return null;
         }
 
+        /// <summary>
+        /// Invoked after the server and clients have started.
+        /// Note: No connection verification has been done at this point
+        /// </summary>
+        protected virtual void OnTimeTravelStartedServerAndClients()
+        {
+        }
+
         /// <summary>
         /// Invoked after the server and clients have started and verified
         /// their connections with each other.
@@ -431,6 +609,14 @@ namespace Unity.Netcode.TestHelpers.Runtime
             yield return null;
         }
 
+        /// <summary>
+        /// Invoked after the server and clients have started and verified
+        /// their connections with each other.
+        /// </summary>
+        protected virtual void OnTimeTravelServerAndClientsConnected()
+        {
+        }
+
         private void ClientNetworkManagerPostStart(NetworkManager networkManager)
         {
             networkManager.name = $"NetworkManager - Client - {networkManager.LocalClientId}";
@@ -457,6 +643,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 {
                     m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
                 }
+
                 if (!m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].ContainsKey(networkManager.LocalClientId))
                 {
                     m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(networkManager.LocalClientId, playerNetworkObject);
@@ -486,6 +673,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             {
                 ClientNetworkManagerPostStart(networkManager);
             }
+
             if (m_UseHost)
             {
 #if UNITY_2023_1_OR_NEWER
@@ -500,6 +688,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
                     {
                         m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
                     }
+
                     if (!m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].ContainsKey(m_ServerNetworkManager.LocalClientId))
                     {
                         m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
@@ -561,6 +750,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
                             {
                                 m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
                             }
+
                             m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
                         }
                     }
@@ -576,6 +766,73 @@ namespace Unity.Netcode.TestHelpers.Runtime
             }
         }
 
+        /// <summary>
+        /// This starts the server and clients as long as <see cref="CanStartServerAndClients"/>
+        /// returns true.
+        /// </summary>
+        protected void StartServerAndClientsWithTimeTravel()
+        {
+            if (CanStartServerAndClients())
+            {
+                VerboseDebug($"Entering {nameof(StartServerAndClientsWithTimeTravel)}");
+
+                // Start the instances and pass in our SceneManagerInitialization action that is invoked immediately after host-server
+                // is started and after each client is started.
+                if (!NetcodeIntegrationTestHelpers.Start(m_UseHost, m_ServerNetworkManager, m_ClientNetworkManagers))
+                {
+                    Debug.LogError("Failed to start instances");
+                    Assert.Fail("Failed to start instances");
+                }
+
+                if (LogAllMessages)
+                {
+                    EnableMessageLogging();
+                }
+
+                RegisterSceneManagerHandler();
+
+                // Notification that the server and clients have been started
+                OnTimeTravelStartedServerAndClients();
+
+                // When true, we skip everything else (most likely a connection oriented test)
+                if (!m_BypassConnectionTimeout)
+                {
+                    // Wait for all clients to connect
+                    WaitForClientsConnectedOrTimeOutWithTimeTravel();
+
+                    AssertOnTimeout($"{nameof(StartServerAndClients)} timed out waiting for all clients to be connected!");
+
+                    if (m_UseHost || m_ServerNetworkManager.IsHost)
+                    {
+#if UNITY_2023_1_OR_NEWER
+                        // Add the server player instance to all m_ClientSidePlayerNetworkObjects entries
+                        var serverPlayerClones = Object.FindObjectsByType<NetworkObject>(FindObjectsSortMode.None).Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);
+#else
+                        // Add the server player instance to all m_ClientSidePlayerNetworkObjects entries
+                        var serverPlayerClones = Object.FindObjectsOfType<NetworkObject>().Where((c) => c.IsPlayerObject && c.OwnerClientId == m_ServerNetworkManager.LocalClientId);
+#endif
+                        foreach (var playerNetworkObject in serverPlayerClones)
+                        {
+                            if (!m_PlayerNetworkObjects.ContainsKey(playerNetworkObject.NetworkManager.LocalClientId))
+                            {
+                                m_PlayerNetworkObjects.Add(playerNetworkObject.NetworkManager.LocalClientId, new Dictionary<ulong, NetworkObject>());
+                            }
+
+                            m_PlayerNetworkObjects[playerNetworkObject.NetworkManager.LocalClientId].Add(m_ServerNetworkManager.LocalClientId, playerNetworkObject);
+                        }
+                    }
+
+                    ClientNetworkManagerPostStartInit();
+
+                    // Notification that at this time the server and client(s) are instantiated,
+                    // started, and connected on both sides.
+                    OnTimeTravelServerAndClientsConnected();
+
+                    VerboseDebug($"Exiting {nameof(StartServerAndClients)}");
+                }
+            }
+        }
+
         /// <summary>
         /// Override this method to control when clients
         /// can fake-load a scene.
@@ -651,12 +908,15 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 m_PlayerNetworkObjects.Clear();
                 s_GlobalNetworkObjects.Clear();
             }
-            catch (Exception e) { throw e; }
+            catch (Exception e)
+            {
+                throw e;
+            }
             finally
             {
                 if (m_PlayerPrefab != null)
                 {
-                    Object.Destroy(m_PlayerPrefab);
+                    Object.DestroyImmediate(m_PlayerPrefab);
                     m_PlayerPrefab = null;
                 }
             }
@@ -680,18 +940,36 @@ namespace Unity.Netcode.TestHelpers.Runtime
             yield return null;
         }
 
+        protected virtual void OnInlineTearDown()
+        {
+        }
+
         [UnityTearDown]
         public IEnumerator TearDown()
         {
+            IntegrationTestSceneHandler.SceneNameToSceneHandles.Clear();
             VerboseDebug($"Entering {nameof(TearDown)}");
-            yield return OnTearDown();
+            if (m_TearDownIsACoroutine)
+            {
+                yield return OnTearDown();
+            }
+            else
+            {
+                OnInlineTearDown();
+            }
 
             if (m_NetworkManagerInstatiationMode == NetworkManagerInstatiationMode.PerTest)
             {
                 ShutdownAndCleanUp();
             }
 
+            if (m_EnableTimeTravel)
+            {
+                ComponentFactory.Deregister<IRealTimeProvider>();
+            }
+
             VerboseDebug($"Exiting {nameof(TearDown)}");
+            LogWaitForMessages();
             NetcodeLogAssert.Dispose();
         }
 
@@ -763,6 +1041,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 {
                     continue;
                 }
+
                 if (CanDestroyNetworkObject(networkObject))
                 {
                     networkObject.NetworkManagerOwner = m_ServerNetworkManager;
@@ -821,10 +1100,49 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 // Otherwise wait for 1 tick interval
                 yield return s_DefaultWaitForTick;
             }
+
             // Stop checking for a timeout
             timeOutHelper.Stop();
         }
 
+
+        /// <summary>
+        /// Waits for the function condition to return true or it will time out. Uses time travel to simulate this
+        /// for the given number of frames, simulating delta times at the application frame rate.
+        /// </summary>
+        public bool WaitForConditionOrTimeOutWithTimeTravel(Func<bool> checkForCondition, int maxTries = 60)
+        {
+            if (checkForCondition == null)
+            {
+                throw new ArgumentNullException($"checkForCondition cannot be null!");
+            }
+
+            if (!m_EnableTimeTravel)
+            {
+                throw new ArgumentException($"Time travel must be enabled to use {nameof(WaitForConditionOrTimeOutWithTimeTravel)}!");
+            }
+
+            var frameRate = Application.targetFrameRate;
+            if (frameRate <= 0)
+            {
+                frameRate = 60;
+            }
+
+            var updateInterval = 1f / frameRate;
+            for (var i = 0; i < maxTries; ++i)
+            {
+                // Simulate a frame passing on all network managers
+                TimeTravel(updateInterval, 1);
+                // Update and check to see if the condition has been met
+                if (checkForCondition.Invoke())
+                {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
         /// <summary>
         /// This version accepts an IConditionalPredicate implementation to provide
         /// more flexibility for checking complex conditional cases.
@@ -847,6 +1165,29 @@ namespace Unity.Netcode.TestHelpers.Runtime
             conditionalPredicate.Finished(timeOutHelper.TimedOut);
         }
 
+        /// <summary>
+        /// This version accepts an IConditionalPredicate implementation to provide
+        /// more flexibility for checking complex conditional cases. Uses time travel to simulate this
+        /// for the given number of frames, simulating delta times at the application frame rate.
+        /// </summary>
+        public bool WaitForConditionOrTimeOutWithTimeTravel(IConditionalPredicate conditionalPredicate, int maxTries = 60)
+        {
+            if (conditionalPredicate == null)
+            {
+                throw new ArgumentNullException($"checkForCondition cannot be null!");
+            }
+
+            if (!m_EnableTimeTravel)
+            {
+                throw new ArgumentException($"Time travel must be enabled to use {nameof(WaitForConditionOrTimeOutWithTimeTravel)}!");
+            }
+
+            conditionalPredicate.Started();
+            var success = WaitForConditionOrTimeOutWithTimeTravel(conditionalPredicate.HasConditionBeenReached, maxTries);
+            conditionalPredicate.Finished(!success);
+            return success;
+        }
+
         /// <summary>
         /// Validates that all remote clients (i.e. non-server) detect they are connected
         /// to the server and that the server reflects the appropriate number of clients
@@ -859,7 +1200,23 @@ namespace Unity.Netcode.TestHelpers.Runtime
             var serverClientCount = m_ServerNetworkManager.IsHost ? remoteClientCount + 1 : remoteClientCount;
 
             yield return WaitForConditionOrTimeOut(() => clientsToCheck.Where((c) => c.IsConnectedClient).Count() == remoteClientCount &&
-            m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);
+                                                         m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);
+        }
+
+        /// <summary>
+        /// Validates that all remote clients (i.e. non-server) detect they are connected
+        /// to the server and that the server reflects the appropriate number of clients
+        /// have connected or it will time out. Uses time travel to simulate this
+        /// for the given number of frames, simulating delta times at the application frame rate.
+        /// </summary>
+        /// <param name="clientsToCheck">An array of clients to be checked</param>
+        protected bool WaitForClientsConnectedOrTimeOutWithTimeTravel(NetworkManager[] clientsToCheck)
+        {
+            var remoteClientCount = clientsToCheck.Length;
+            var serverClientCount = m_ServerNetworkManager.IsHost ? remoteClientCount + 1 : remoteClientCount;
+
+            return WaitForConditionOrTimeOutWithTimeTravel(() => clientsToCheck.Where((c) => c.IsConnectedClient).Count() == remoteClientCount &&
+                                                                 m_ServerNetworkManager.ConnectedClients.Count == serverClientCount);
         }
 
         /// <summary>
@@ -871,6 +1228,16 @@ namespace Unity.Netcode.TestHelpers.Runtime
             yield return WaitForClientsConnectedOrTimeOut(m_ClientNetworkManagers);
         }
 
+        /// <summary>
+        /// Overloaded method that just passes in all clients to
+        /// <see cref="WaitForClientsConnectedOrTimeOut(NetworkManager[])"/> Uses time travel to simulate this
+        /// for the given number of frames, simulating delta times at the application frame rate.
+        /// </summary>
+        protected bool WaitForClientsConnectedOrTimeOutWithTimeTravel()
+        {
+            return WaitForClientsConnectedOrTimeOutWithTimeTravel(m_ClientNetworkManagers);
+        }
+
         internal IEnumerator WaitForMessageReceived<T>(List<NetworkManager> wiatForReceivedBy, ReceiptType type = ReceiptType.Handled) where T : INetworkMessage
         {
             // Build our message hook entries tables so we can determine if all clients received spawn or ownership messages
@@ -881,17 +1248,18 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 messageHook.AssignMessageType<T>();
                 messageHookEntriesForSpawn.Add(messageHook);
             }
+
             // Used to determine if all clients received the CreateObjectMessage
             var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
             yield return WaitForConditionOrTimeOut(hooks);
             Assert.False(s_GlobalTimeoutHelper.TimedOut);
         }
 
-        internal IEnumerator WaitForMessagesReceived(List<Type> messagesInOrder, List<NetworkManager> wiatForReceivedBy, ReceiptType type = ReceiptType.Handled)
+        internal IEnumerator WaitForMessagesReceived(List<Type> messagesInOrder, List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled)
         {
             // Build our message hook entries tables so we can determine if all clients received spawn or ownership messages
             var messageHookEntriesForSpawn = new List<MessageHookEntry>();
-            foreach (var clientNetworkManager in wiatForReceivedBy)
+            foreach (var clientNetworkManager in waitForReceivedBy)
             {
                 foreach (var message in messagesInOrder)
                 {
@@ -900,12 +1268,49 @@ namespace Unity.Netcode.TestHelpers.Runtime
                     messageHookEntriesForSpawn.Add(messageHook);
                 }
             }
+
             // Used to determine if all clients received the CreateObjectMessage
             var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
             yield return WaitForConditionOrTimeOut(hooks);
             Assert.False(s_GlobalTimeoutHelper.TimedOut);
         }
 
+
+        internal void WaitForMessageReceivedWithTimeTravel<T>(List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled) where T : INetworkMessage
+        {
+            // Build our message hook entries tables so we can determine if all clients received spawn or ownership messages
+            var messageHookEntriesForSpawn = new List<MessageHookEntry>();
+            foreach (var clientNetworkManager in waitForReceivedBy)
+            {
+                var messageHook = new MessageHookEntry(clientNetworkManager, type);
+                messageHook.AssignMessageType<T>();
+                messageHookEntriesForSpawn.Add(messageHook);
+            }
+
+            // Used to determine if all clients received the CreateObjectMessage
+            var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
+            Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks));
+        }
+
+        internal void WaitForMessagesReceivedWithTimeTravel(List<Type> messagesInOrder, List<NetworkManager> waitForReceivedBy, ReceiptType type = ReceiptType.Handled)
+        {
+            // Build our message hook entries tables so we can determine if all clients received spawn or ownership messages
+            var messageHookEntriesForSpawn = new List<MessageHookEntry>();
+            foreach (var clientNetworkManager in waitForReceivedBy)
+            {
+                foreach (var message in messagesInOrder)
+                {
+                    var messageHook = new MessageHookEntry(clientNetworkManager, type);
+                    messageHook.AssignMessageType(message);
+                    messageHookEntriesForSpawn.Add(messageHook);
+                }
+            }
+
+            // Used to determine if all clients received the CreateObjectMessage
+            var hooks = new MessageHooksConditional(messageHookEntriesForSpawn);
+            Assert.True(WaitForConditionOrTimeOutWithTimeTravel(hooks));
+        }
+
         /// <summary>
         /// Creates a basic NetworkObject test prefab, assigns it to a new
         /// NetworkPrefab entry, and then adds it to the server and client(s)
@@ -916,22 +1321,11 @@ namespace Unity.Netcode.TestHelpers.Runtime
         protected GameObject CreateNetworkObjectPrefab(string baseName)
         {
             var prefabCreateAssertError = $"You can only invoke this method during {nameof(OnServerAndClientsCreated)} " +
-                $"but before {nameof(OnStartedServerAndClients)}!";
+                                          $"but before {nameof(OnStartedServerAndClients)}!";
             Assert.IsNotNull(m_ServerNetworkManager, prefabCreateAssertError);
             Assert.IsFalse(m_ServerNetworkManager.IsListening, prefabCreateAssertError);
 
-            var gameObject = new GameObject();
+            return NetcodeIntegrationTestHelpers.CreateNetworkObjectPrefab(baseName, m_ServerNetworkManager, m_ClientNetworkManagers);
-            gameObject.name = baseName;
-            var networkObject = gameObject.AddComponent<NetworkObject>();
-            networkObject.NetworkManagerOwner = m_ServerNetworkManager;
-            NetcodeIntegrationTestHelpers.MakeNetworkObjectTestPrefab(networkObject);
-            var networkPrefab = new NetworkPrefab() { Prefab = gameObject };
-            m_ServerNetworkManager.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
-            foreach (var clientNetworkManager in m_ClientNetworkManagers)
-            {
-                clientNetworkManager.NetworkConfig.NetworkPrefabs.Add(networkPrefab);
-            }
-            return gameObject;
         }
 
         /// <summary>
@@ -1001,6 +1395,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             {
                 gameObjectsSpawned.Add(SpawnObject(prefabNetworkObject, owner, destroyWithScene));
             }
+
             return gameObjectsSpawned;
         }
 
@@ -1009,7 +1404,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </summary>
         public NetcodeIntegrationTest()
         {
-
         }
 
         /// <summary>
@@ -1039,7 +1433,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </summary>
         protected void AssertOnTimeout(string timeOutErrorMessage, TimeoutHelper assignedTimeoutHelper = null)
         {
-            var timeoutHelper = assignedTimeoutHelper != null ? assignedTimeoutHelper : s_GlobalTimeoutHelper;
+            var timeoutHelper = assignedTimeoutHelper ?? s_GlobalTimeoutHelper;
             Assert.False(timeoutHelper.TimedOut, timeOutErrorMessage);
         }
 
@@ -1055,9 +1449,145 @@ namespace Unity.Netcode.TestHelpers.Runtime
                 {
                     continue;
                 }
+
                 VerboseDebug($"Unloading scene {scene.name}-{scene.handle}");
                 var asyncOperation = SceneManager.UnloadSceneAsync(scene);
             }
         }
+
+        private System.Text.StringBuilder m_WaitForLog = new System.Text.StringBuilder();
+
+        private void LogWaitForMessages()
+        {
+            VerboseDebug(m_WaitForLog.ToString());
+            m_WaitForLog.Clear();
+        }
+
+        private IEnumerator WaitForTickAndFrames(NetworkManager networkManager, int tickCount, float targetFrames)
+        {
+            var tickAndFramesConditionMet = false;
+            var frameCount = 0;
+            var waitForFixedUpdate = new WaitForFixedUpdate();
+            m_WaitForLog.Append($"[NetworkManager-{networkManager.LocalClientId}][WaitForTicks-Begin] Waiting for ({tickCount}) network ticks and ({targetFrames}) frames to pass.\n");
+            var tickStart = networkManager.NetworkTickSystem.LocalTime.Tick;
+            while (!tickAndFramesConditionMet)
+            {
+                // Wait until both tick and frame counts have reached their targeted values
+                if ((networkManager.NetworkTickSystem.LocalTime.Tick - tickStart) >= tickCount && frameCount >= targetFrames)
+                {
+                    tickAndFramesConditionMet = true;
+                }
+                else
+                {
+                    yield return waitForFixedUpdate;
+                    frameCount++;
+                    // In the event something is broken with time systems (or the like)
+                    // Exit if we have exceeded 1000 frames
+                    if (frameCount >= 1000.0f)
+                    {
+                        tickAndFramesConditionMet = true;
+                    }
+                }
+            }
+
+            m_WaitForLog.Append($"[NetworkManager-{networkManager.LocalClientId}][WaitForTicks-End] Waited for ({networkManager.NetworkTickSystem.LocalTime.Tick - tickStart}) network ticks and ({frameCount}) frames to pass.\n");
+            yield break;
+        }
+
+        /// <summary>
+        /// Yields until specified amount of network ticks and the expected number of frames has been passed.
+        /// </summary>
+        protected IEnumerator WaitForTicks(NetworkManager networkManager, int count)
+        {
+            var targetTick = networkManager.NetworkTickSystem.LocalTime.Tick + count;
+
+            // Calculate the expected number of frame updates that should occur during the tick count wait period
+            var frameFrequency = 1.0f / (Application.targetFrameRate >= 60 && Application.targetFrameRate <= 100 ? Application.targetFrameRate : 60.0f);
+            var tickFrequency = 1.0f / networkManager.NetworkConfig.TickRate;
+            var framesPerTick = tickFrequency / frameFrequency;
+
+            // Total number of frames to occur over the specified number of ticks
+            var totalFrameCount = framesPerTick * count;
+            m_WaitForLog.Append($"[NetworkManager-{networkManager.LocalClientId}][WaitForTicks] TickRate ({networkManager.NetworkConfig.TickRate}) | Tick Wait ({count}) | TargetFrameRate ({Application.targetFrameRate}) | Target Frames ({framesPerTick * count})\n");
+            yield return WaitForTickAndFrames(networkManager, count, totalFrameCount);
+        }
+
+        /// <summary>
+        /// Simulate a number of frames passing over a specific amount of time.
+        /// The delta time simulated for each frame will be evenly divided as time/numFrames
+        /// This will only simulate the netcode update loop, as well as update events on
+        /// NetworkBehaviour instances, and will not simulate any Unity update processes (physics, etc)
+        /// </summary>
+        /// <param name="amountOfTimeInSeconds"></param>
+        /// <param name="numFramesToSimulate"></param>
+        protected static void TimeTravel(double amountOfTimeInSeconds, int numFramesToSimulate)
+        {
+            var interval = amountOfTimeInSeconds / numFramesToSimulate;
+            for (var i = 0; i < numFramesToSimulate; ++i)
+            {
+                MockTimeProvider.TimeTravel(interval);
+                SimulateOneFrame();
+            }
+        }
+
+        /// <summary>
+        /// Helper function to time travel exactly one tick's worth of time at the current frame and tick rates.
+        /// </summary>
+        public static void TimeTravelToNextTick()
+        {
+            var timePassed = 1.0f / k_DefaultTickRate;
+            var frameRate = Application.targetFrameRate;
+            if (frameRate <= 0)
+            {
+                frameRate = 60;
+            }
+
+            var frames = Math.Max((int)(timePassed / frameRate), 1);
+            TimeTravel(timePassed, frames);
+        }
+
+        /// <summary>
+        /// Simulates one SDK frame. This can be used even without TimeTravel, though it's of somewhat less use
+        /// without TimeTravel, as, without the mock transport, it will likely not provide enough time for any
+        /// sent messages to be received even if called dozens of times.
+        /// </summary>
+        public static void SimulateOneFrame()
+        {
+            foreach (NetworkUpdateStage stage in Enum.GetValues(typeof(NetworkUpdateStage)))
+            {
+                NetworkUpdateLoop.RunNetworkUpdateStage(stage);
+                string methodName = string.Empty;
+                switch (stage)
+                {
+                    case NetworkUpdateStage.FixedUpdate:
+                        methodName = "FixedUpdate"; // mapping NetworkUpdateStage.FixedUpdate to MonoBehaviour.FixedUpdate
+                        break;
+                    case NetworkUpdateStage.Update:
+                        methodName = "Update"; // mapping NetworkUpdateStage.Update to MonoBehaviour.Update
+                        break;
+                    case NetworkUpdateStage.PreLateUpdate:
+                        methodName = "LateUpdate"; // mapping NetworkUpdateStage.PreLateUpdate to MonoBehaviour.LateUpdate
+                        break;
+                }
+
+                if (!string.IsNullOrEmpty(methodName))
+                {
+#if UNITY_2023_1_OR_NEWER
+                    foreach (var behaviour in Object.FindObjectsByType<NetworkBehaviour>(FindObjectsSortMode.InstanceID))
+#else
+                    foreach (var behaviour in Object.FindObjectsOfType<NetworkBehaviour>())
+#endif
+                    {
+                        var method = behaviour.GetType().GetMethod(methodName, BindingFlags.NonPublic | BindingFlags.Instance);
+                        if (method == null)
+                        {
+                            method = behaviour.GetType().GetMethod(methodName, BindingFlags.Public | BindingFlags.Instance);
+                        }
+
+                        method?.Invoke(behaviour, new object[] { });
+                    }
+                }
+            }
+        }
     }
 }

TestHelpers/Runtime/NetcodeIntegrationTestHelpers.cs

@@ -182,14 +182,20 @@ namespace Unity.Netcode.TestHelpers.Runtime
             unityTransport.ConnectTimeoutMS = 500;
 
             // Set the NetworkConfig
-            networkManager.NetworkConfig = new NetworkConfig()
+            networkManager.NetworkConfig ??= new NetworkConfig();
-            {
+            networkManager.NetworkConfig.NetworkTransport = unityTransport;
-                // Set transport
-                NetworkTransport = unityTransport
-            };
         }
 
-        public static NetworkManager CreateServer()
+        private static void AddMockTransport(NetworkManager networkManager)
+        {
+            // Create transport
+            var mockTransport = networkManager.gameObject.AddComponent<MockTransport>();
+            // Set the NetworkConfig
+            networkManager.NetworkConfig ??= new NetworkConfig();
+            networkManager.NetworkConfig.NetworkTransport = mockTransport;
+        }
+
+        public static NetworkManager CreateServer(bool mockTransport = false)
         {
             // Create gameObject
             var go = new GameObject("NetworkManager - Server");
@@ -197,7 +203,14 @@ namespace Unity.Netcode.TestHelpers.Runtime
             // Create networkManager component
             var server = go.AddComponent<NetworkManager>();
             NetworkManagerInstances.Insert(0, server);
-            AddUnityTransport(server);
+            if (mockTransport)
+            {
+                AddMockTransport(server);
+            }
+            else
+            {
+                AddUnityTransport(server);
+            }
             return server;
         }
 
@@ -209,20 +222,20 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// <param name="clients">The clients NetworkManagers</param>
         /// <param name="targetFrameRate">The targetFrameRate of the Unity engine to use while the multi instance helper is running. Will be reset on shutdown.</param>
         /// <param name="serverFirst">This determines if the server or clients will be instantiated first (defaults to server first)</param>
-        public static bool Create(int clientCount, out NetworkManager server, out NetworkManager[] clients, int targetFrameRate = 60, bool serverFirst = true)
+        public static bool Create(int clientCount, out NetworkManager server, out NetworkManager[] clients, int targetFrameRate = 60, bool serverFirst = true, bool useMockTransport = false)
         {
             s_NetworkManagerInstances = new List<NetworkManager>();
             server = null;
             if (serverFirst)
             {
-                server = CreateServer();
+                server = CreateServer(useMockTransport);
             }
 
-            CreateNewClients(clientCount, out clients);
+            CreateNewClients(clientCount, out clients, useMockTransport);
 
             if (!serverFirst)
             {
-                server = CreateServer();
+                server = CreateServer(useMockTransport);
             }
 
             s_OriginalTargetFrameRate = Application.targetFrameRate;
@@ -231,13 +244,20 @@ namespace Unity.Netcode.TestHelpers.Runtime
             return true;
         }
 
-        internal static NetworkManager CreateNewClient(int identifier)
+        internal static NetworkManager CreateNewClient(int identifier, bool mockTransport = false)
         {
             // Create gameObject
             var go = new GameObject("NetworkManager - Client - " + identifier);
             // Create networkManager component
             var networkManager = go.AddComponent<NetworkManager>();
-            AddUnityTransport(networkManager);
+            if (mockTransport)
+            {
+                AddMockTransport(networkManager);
+            }
+            else
+            {
+                AddUnityTransport(networkManager);
+            }
             return networkManager;
         }
 
@@ -247,13 +267,13 @@ namespace Unity.Netcode.TestHelpers.Runtime
         /// </summary>
         /// <param name="clientCount">The amount of clients</param>
         /// <param name="clients"></param>
-        public static bool CreateNewClients(int clientCount, out NetworkManager[] clients)
+        public static bool CreateNewClients(int clientCount, out NetworkManager[] clients, bool useMockTransport = false)
         {
             clients = new NetworkManager[clientCount];
             for (int i = 0; i < clientCount; i++)
             {
                 // Create networkManager component
-                clients[i] = CreateNewClient(i);
+                clients[i] = CreateNewClient(i, useMockTransport);
             }
 
             NetworkManagerInstances.AddRange(clients);
@@ -317,7 +337,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             {
                 if (networkManager.gameObject != null)
                 {
-                    Object.Destroy(networkManager.gameObject);
+                    Object.DestroyImmediate(networkManager.gameObject);
                 }
             }
 
@@ -342,6 +362,12 @@ namespace Unity.Netcode.TestHelpers.Runtime
             return true;
         }
 
+        private static bool VerifySceneIsValidForClientsToUnload(Scene scene)
+        {
+            // Unless specifically set, we always return false
+            return false;
+        }
+
         /// <summary>
         /// This registers scene validation callback for the server to prevent it from telling connecting
         /// clients to synchronize (i.e. load) the test runner scene.  This will also register the test runner
@@ -354,10 +380,21 @@ namespace Unity.Netcode.TestHelpers.Runtime
             if (networkManager.IsServer && networkManager.SceneManager.VerifySceneBeforeLoading == null)
             {
                 networkManager.SceneManager.VerifySceneBeforeLoading = VerifySceneIsValidForClientsToLoad;
+
                 // If a unit/integration test does not handle this on their own, then Ignore the validation warning
                 networkManager.SceneManager.DisableValidationWarnings(true);
             }
 
+            // For testing purposes, all clients always set the VerifySceneBeforeUnloading callback and enabled
+            // PostSynchronizationSceneUnloading. Where tests that expect clients to unload scenes should override
+            // the callback and return true for the scenes the client(s) is/are allowed to unload.
+            if (!networkManager.IsServer && networkManager.SceneManager.VerifySceneBeforeUnloading == null)
+            {
+                networkManager.SceneManager.VerifySceneBeforeUnloading = VerifySceneIsValidForClientsToUnload;
+                networkManager.SceneManager.PostSynchronizationSceneUnloading = true;
+            }
+
+
             // Register the test runner scene so it will be able to synchronize NetworkObjects without logging a
             // warning about using the currently active scene
             var scene = SceneManager.GetActiveScene();
@@ -486,6 +523,36 @@ namespace Unity.Netcode.TestHelpers.Runtime
             }
         }
 
+        public static GameObject CreateNetworkObjectPrefab(string baseName, NetworkManager server, params NetworkManager[] clients)
+        {
+            void AddNetworkPrefab(NetworkConfig config, NetworkPrefab prefab)
+            {
+                config.Prefabs.Add(prefab);
+            }
+
+            var prefabCreateAssertError = $"You can only invoke this method before starting the network manager(s)!";
+            Assert.IsNotNull(server, prefabCreateAssertError);
+            Assert.IsFalse(server.IsListening, prefabCreateAssertError);
+
+            var gameObject = new GameObject
+            {
+                name = baseName
+            };
+            var networkObject = gameObject.AddComponent<NetworkObject>();
+            networkObject.NetworkManagerOwner = server;
+            MakeNetworkObjectTestPrefab(networkObject);
+            var networkPrefab = new NetworkPrefab() { Prefab = gameObject };
+
+            // We could refactor this test framework to share a NetworkPrefabList instance, but at this point it's
+            // probably more trouble than it's worth to verify these lists stay in sync across all tests...
+            AddNetworkPrefab(server.NetworkConfig, networkPrefab);
+            foreach (var clientNetworkManager in clients)
+            {
+                AddNetworkPrefab(clientNetworkManager.NetworkConfig, networkPrefab);
+            }
+            return gameObject;
+        }
+
         // We use GameObject instead of SceneObject to be able to keep hierarchy
         public static void MarkAsSceneObjectRoot(GameObject networkObjectRoot, NetworkManager server, NetworkManager[] clients)
         {
@@ -512,15 +579,6 @@ namespace Unity.Netcode.TestHelpers.Runtime
             }
         }
 
-        /// <summary>
-        /// Waits (yields) until specified amount of network ticks has been passed.
-        /// </summary>
-        public static IEnumerator WaitForTicks(NetworkManager networkManager, int count)
-        {
-            var targetTick = networkManager.NetworkTickSystem.LocalTime.Tick + count;
-            yield return new WaitUntil(() => networkManager.NetworkTickSystem.LocalTime.Tick >= targetTick);
-        }
-
         /// <summary>
         /// Waits on the client side to be connected.
         /// </summary>
@@ -699,6 +757,40 @@ namespace Unity.Netcode.TestHelpers.Runtime
             }
         }
 
+        /// <summary>
+        /// Gets a NetworkObject instance as it's represented by a certain peer.
+        /// </summary>
+        /// <param name="predicate">The predicate used to filter for your target NetworkObject</param>
+        /// <param name="representation">The representation to get the object from</param>
+        /// <param name="result">The result</param>
+        /// <param name="failIfNull">Whether or not to fail if no object is found and result is null</param>
+        /// <param name="maxFrames">The max frames to wait for</param>
+        public static void GetNetworkObjectByRepresentationWithTimeTravel(Func<NetworkObject, bool> predicate, NetworkManager representation, ResultWrapper<NetworkObject> result, bool failIfNull = true, int maxTries = 60)
+        {
+            if (result == null)
+            {
+                throw new ArgumentNullException("Result cannot be null");
+            }
+
+            if (predicate == null)
+            {
+                throw new ArgumentNullException("Predicate cannot be null");
+            }
+
+            var tries = 0;
+            while (++tries < maxTries && !representation.SpawnManager.SpawnedObjects.Any(x => predicate(x.Value)))
+            {
+                NetcodeIntegrationTest.SimulateOneFrame();
+            }
+
+            result.Result = representation.SpawnManager.SpawnedObjects.FirstOrDefault(x => predicate(x.Value)).Value;
+
+            if (failIfNull && result.Result == null)
+            {
+                Assert.Fail("NetworkObject could not be found");
+            }
+        }
+
         /// <summary>
         /// Waits for a predicate condition to be met
         /// </summary>

TestHelpers/Runtime/NetworkManagerHelper.cs

@@ -1,8 +1,8 @@
 using System;
 using System.Collections.Generic;
-using UnityEngine;
 using NUnit.Framework;
 using Unity.Netcode.Transports.UTP;
+using UnityEngine;
 
 namespace Unity.Netcode.TestHelpers.Runtime
 {

TestHelpers/Runtime/TimeoutHelper.cs

@@ -8,30 +8,67 @@ namespace Unity.Netcode.TestHelpers.Runtime
     /// </summary>
     public class TimeoutHelper
     {
-        private const float k_DefaultTimeOutWaitPeriod = 2.0f;
+        protected const float k_DefaultTimeOutWaitPeriod = 2.0f;
+
 
         private float m_MaximumTimeBeforeTimeOut;
         private float m_TimeOutPeriod;
 
-        private bool m_IsStarted;
+        protected bool m_IsStarted { get; private set; }
         public bool TimedOut { get; internal set; }
 
+        private float m_TimeStarted;
+        private float m_TimeStopped;
+
+        public float GetTimeElapsed()
+        {
+            if (m_IsStarted)
+            {
+                return Time.realtimeSinceStartup - m_TimeStarted;
+            }
+            else
+            {
+                return m_TimeStopped - m_TimeStarted;
+            }
+        }
+
+        protected virtual void OnStart()
+        {
+        }
+
         public void Start()
         {
+            m_TimeStopped = 0.0f;
+            m_TimeStarted = Time.realtimeSinceStartup;
             m_MaximumTimeBeforeTimeOut = Time.realtimeSinceStartup + m_TimeOutPeriod;
             m_IsStarted = true;
             TimedOut = false;
+            OnStart();
+        }
+
+        protected virtual void OnStop()
+        {
         }
 
         public void Stop()
         {
+            if (m_TimeStopped == 0.0f)
+            {
+                m_TimeStopped = Time.realtimeSinceStartup;
+            }
             TimedOut = HasTimedOut();
             m_IsStarted = false;
+            OnStop();
+        }
+
+        protected virtual bool OnHasTimedOut()
+        {
+            return m_IsStarted ? m_MaximumTimeBeforeTimeOut < Time.realtimeSinceStartup : TimedOut;
         }
 
         public bool HasTimedOut()
         {
-            return m_IsStarted ? m_MaximumTimeBeforeTimeOut < Time.realtimeSinceStartup : TimedOut;
+            return OnHasTimedOut();
         }
 
         public TimeoutHelper(float timeOutPeriod = k_DefaultTimeOutWaitPeriod)
@@ -39,4 +76,70 @@ namespace Unity.Netcode.TestHelpers.Runtime
             m_TimeOutPeriod = timeOutPeriod;
         }
     }
+
+    /// <summary>
+    /// This can be used in place of TimeoutHelper if you suspect a test is having
+    /// issues on a system where the frame rate is running slow than expected and
+    /// allowing a certain number of frame updates is required.
+    /// </summary>
+    public class TimeoutFrameCountHelper : TimeoutHelper
+    {
+        private const uint k_DefaultTickRate = 30;
+
+        private float m_TotalFramesToWait;
+        private int m_StartFrameCount;
+        private int m_EndFrameCount;
+        private bool m_ReachedFrameCount;
+
+        public int GetFrameCount()
+        {
+            if (m_IsStarted)
+            {
+                return Time.frameCount - m_StartFrameCount;
+            }
+            else
+            {
+                return m_EndFrameCount - m_StartFrameCount;
+            }
+        }
+
+        protected override void OnStop()
+        {
+            if (m_EndFrameCount == 0)
+            {
+                m_EndFrameCount = Time.frameCount;
+            }
+            base.OnStop();
+        }
+
+        protected override bool OnHasTimedOut()
+        {
+            var currentFrameCountDelta = Time.frameCount - m_StartFrameCount;
+            if (m_IsStarted)
+            {
+                m_ReachedFrameCount = currentFrameCountDelta >= m_TotalFramesToWait;
+            }
+            // Only time out if we have both exceeded the time period and the expected number of frames has reached the expected number of frames
+            // (this handles the scenario where some systems are running a much lower frame rate)
+            return m_ReachedFrameCount && base.OnHasTimedOut();
+        }
+
+        protected override void OnStart()
+        {
+            m_EndFrameCount = 0;
+            m_StartFrameCount = Time.frameCount;
+            base.OnStart();
+        }
+
+        public TimeoutFrameCountHelper(float timeOutPeriod = k_DefaultTimeOutWaitPeriod, uint tickRate = k_DefaultTickRate) : base(timeOutPeriod)
+        {
+            // Calculate the expected number of frame updates that should occur during the tick count wait period
+            var frameFrequency = 1.0f / (Application.targetFrameRate >= 60 && Application.targetFrameRate <= 100 ? Application.targetFrameRate : 60.0f);
+            var tickFrequency = 1.0f / tickRate;
+            var framesPerTick = tickFrequency / frameFrequency;
+            var totalExpectedTicks = timeOutPeriod / tickFrequency;
+
+            m_TotalFramesToWait = framesPerTick * totalExpectedTicks;
+        }
+    }
 }

Tests/Editor/Build/BuildTests.cs

@@ -12,7 +12,6 @@ namespace Unity.Netcode.EditorTests
         public const string DefaultBuildScenePath = "Tests/Editor/Build/BuildTestScene.unity";
 
         [Test]
-        [Ignore("Disabling this test on release/1.2.0 branch due to Burst failures caused when running with upm ci")]
         public void BasicBuildTest()
         {
             var execAssembly = Assembly.GetExecutingAssembly();

Tests/Editor/DisconnectMessageTests.cs

@@ -10,8 +10,10 @@ namespace Unity.Netcode.EditorTests
         {
             var networkContext = new NetworkContext();
             var writer = new FastBufferWriter(20, Allocator.Temp, 20);
-            var msg = new DisconnectReasonMessage();
+            var msg = new DisconnectReasonMessage
-            msg.Reason = string.Empty;
+            {
+                Reason = string.Empty
+            };
             msg.Serialize(writer, msg.Version);
 
             var fbr = new FastBufferReader(writer, Allocator.Temp);
@@ -26,8 +28,10 @@ namespace Unity.Netcode.EditorTests
         {
             var networkContext = new NetworkContext();
             var writer = new FastBufferWriter(20, Allocator.Temp, 20);
-            var msg = new DisconnectReasonMessage();
+            var msg = new DisconnectReasonMessage
-            msg.Reason = "Foo";
+            {
+                Reason = "Foo"
+            };
             msg.Serialize(writer, msg.Version);
 
             var fbr = new FastBufferReader(writer, Allocator.Temp);
@@ -42,8 +46,10 @@ namespace Unity.Netcode.EditorTests
         {
             var networkContext = new NetworkContext();
             var writer = new FastBufferWriter(20, Allocator.Temp, 20);
-            var msg = new DisconnectReasonMessage();
+            var msg = new DisconnectReasonMessage
-            msg.Reason = "ThisStringIsWayLongerThanTwentyBytes";
+            {
+                Reason = "ThisStringIsWayLongerThanTwentyBytes"
+            };
             msg.Serialize(writer, msg.Version);
 
             var fbr = new FastBufferReader(writer, Allocator.Temp);

Tests/Editor/Messaging/MessageCorruptionTests.cs

@@ -0,0 +1,203 @@
+using System;
+using System.Collections.Generic;
+using System.Text.RegularExpressions;
+using NUnit.Framework;
+using NUnit.Framework.Internal;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace Unity.Netcode.EditorTests
+{
+    public class MessageCorruptionTests
+    {
+
+        private struct TestMessage : INetworkMessage, INetworkSerializeByMemcpy
+        {
+            public ForceNetworkSerializeByMemcpy<Guid> Value;
+            public static bool Handled;
+            public static bool Deserialized;
+
+            public void Serialize(FastBufferWriter writer, int targetVersion)
+            {
+                writer.WriteValueSafe(Value);
+            }
+
+            public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+            {
+                Deserialized = true;
+                reader.ReadValueSafe(out Value);
+                return true;
+            }
+
+            public void Handle(ref NetworkContext context)
+            {
+                Handled = true;
+            }
+
+            public int Version => 0;
+        }
+
+        private class TestMessageProvider : IMessageProvider
+        {
+            public List<MessagingSystem.MessageWithHandler> GetMessages()
+            {
+                return new List<MessagingSystem.MessageWithHandler>
+                {
+                    new MessagingSystem.MessageWithHandler
+                    {
+                        MessageType = typeof(TestMessage),
+                        Handler = MessagingSystem.ReceiveMessage<TestMessage>,
+                        GetVersion = MessagingSystem.CreateMessageAndGetVersion<TestMessage>
+                    }
+                };
+            }
+        }
+
+        public enum TypeOfCorruption
+        {
+            OffsetPlus,
+            OffsetMinus,
+            CorruptBytes,
+            Truncated,
+            AdditionalGarbageData,
+        }
+
+        private class TestMessageSender : IMessageSender
+        {
+
+            public TypeOfCorruption Corruption;
+            public List<byte[]> MessageQueue = new List<byte[]>();
+
+            public unsafe void Send(ulong clientId, NetworkDelivery delivery, FastBufferWriter batchData)
+            {
+                switch (Corruption)
+                {
+                    case TypeOfCorruption.OffsetPlus:
+                        {
+                            using var subWriter = new FastBufferWriter(batchData.Length + 1, Allocator.Temp);
+                            subWriter.WriteByteSafe(0);
+                            subWriter.WriteBytesSafe(batchData.GetUnsafePtr(), batchData.Length);
+                            MessageQueue.Add(subWriter.ToArray());
+                            break;
+                        }
+                    case TypeOfCorruption.OffsetMinus:
+                        {
+                            using var subWriter = new FastBufferWriter(batchData.Length - 1, Allocator.Temp);
+                            subWriter.WriteBytesSafe(batchData.GetUnsafePtr() + 1, batchData.Length - 1);
+                            MessageQueue.Add(subWriter.ToArray());
+                            break;
+                        }
+                    case TypeOfCorruption.CorruptBytes:
+                        batchData.Seek(batchData.Length - 2);
+                        var currentByte = batchData.GetUnsafePtr()[0];
+                        batchData.WriteByteSafe((byte)(currentByte == 0 ? 1 : 0));
+                        MessageQueue.Add(batchData.ToArray());
+                        break;
+                    case TypeOfCorruption.Truncated:
+                        batchData.Truncate(batchData.Length - 1);
+                        MessageQueue.Add(batchData.ToArray());
+                        break;
+                    case TypeOfCorruption.AdditionalGarbageData:
+                        batchData.Seek(batchData.Length);
+                        batchData.WriteByteSafe(0);
+                        MessageQueue.Add(batchData.ToArray());
+                        break;
+                }
+            }
+        }
+
+        private MessagingSystem m_MessagingSystem;
+        private TestMessageSender m_MessageSender;
+
+        [SetUp]
+        public void SetUp()
+        {
+            TestMessage.Handled = false;
+            TestMessage.Deserialized = false;
+            m_MessageSender = new TestMessageSender();
+
+            m_MessagingSystem = new MessagingSystem(m_MessageSender, this, new TestMessageProvider());
+
+            m_MessagingSystem.ClientConnected(0);
+            m_MessagingSystem.SetVersion(0, XXHash.Hash32(typeof(TestMessage).FullName), 0);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            m_MessagingSystem.Dispose();
+        }
+
+        private TestMessage GetMessage()
+        {
+            return new TestMessage
+            {
+                Value = Guid.NewGuid()
+            };
+        }
+
+        [Test]
+        public unsafe void WhenPacketsAreCorrupted_TheyDontGetProcessed([Values] TypeOfCorruption typeOfCorruption)
+        {
+            m_MessageSender.Corruption = typeOfCorruption;
+
+            switch (typeOfCorruption)
+            {
+                case TypeOfCorruption.OffsetMinus:
+                case TypeOfCorruption.OffsetPlus:
+                    LogAssert.Expect(LogType.Error, new Regex("Received a packet with an invalid Magic Value\\."));
+                    break;
+                case TypeOfCorruption.Truncated:
+                case TypeOfCorruption.AdditionalGarbageData:
+                    LogAssert.Expect(LogType.Error, new Regex("Received a packet with an invalid Batch Size Value\\."));
+                    break;
+                case TypeOfCorruption.CorruptBytes:
+                    LogAssert.Expect(LogType.Error, new Regex("Received a packet with an invalid Hash Value\\."));
+                    break;
+            }
+
+            // Dummy batch header
+            var batchHeader = new BatchHeader
+            {
+                BatchCount = 1
+            };
+            var messageHeader = new MessageHeader
+            {
+                MessageSize = (ushort)UnsafeUtility.SizeOf<TestMessage>(),
+                MessageType = m_MessagingSystem.GetMessageType(typeof(TestMessage)),
+            };
+            var message = GetMessage();
+
+            var writer = new FastBufferWriter(1300, Allocator.Temp);
+            using (writer)
+            {
+                writer.TryBeginWrite(FastBufferWriter.GetWriteSize(batchHeader) +
+                                     FastBufferWriter.GetWriteSize(messageHeader) +
+                                     FastBufferWriter.GetWriteSize(message));
+                writer.WriteValue(batchHeader);
+                writer.WriteValue(messageHeader);
+                writer.WriteValue(message);
+
+                // Fill out the rest of the batch header
+                writer.Seek(0);
+                batchHeader = new BatchHeader
+                {
+                    Magic = BatchHeader.MagicValue,
+                    BatchSize = writer.Length,
+                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
+                    BatchCount = 1
+                };
+                writer.WriteValue(batchHeader);
+                m_MessageSender.Send(0, NetworkDelivery.Reliable, writer);
+
+                var receivedMessage = m_MessageSender.MessageQueue[0];
+                m_MessageSender.MessageQueue.Clear();
+                m_MessagingSystem.HandleIncomingData(0, new ArraySegment<byte>(receivedMessage), 0);
+                Assert.IsFalse(TestMessage.Deserialized);
+                Assert.IsFalse(TestMessage.Handled);
+            }
+        }
+    }
+}

Tests/Editor/Messaging/MessageCorruptionTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d3c01a0b5a0e478ebc5182fe339bde04
+timeCreated: 1676997550

Tests/Editor/Messaging/MessageReceivingTests.cs

@@ -114,11 +114,11 @@ namespace Unity.Netcode.EditorTests
         }
 
         [Test]
-        public void WhenHandlingIncomingData_ReceiveIsNotCalledBeforeProcessingIncomingMessageQueue()
+        public unsafe void WhenHandlingIncomingData_ReceiveIsNotCalledBeforeProcessingIncomingMessageQueue()
         {
             var batchHeader = new BatchHeader
             {
-                BatchSize = 1
+                BatchCount = 1
             };
             var messageHeader = new MessageHeader
             {
@@ -137,6 +137,17 @@ namespace Unity.Netcode.EditorTests
                 writer.WriteValue(messageHeader);
                 writer.WriteValue(message);
 
+                // Fill out the rest of the batch header
+                writer.Seek(0);
+                batchHeader = new BatchHeader
+                {
+                    Magic = BatchHeader.MagicValue,
+                    BatchSize = writer.Length,
+                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
+                    BatchCount = 1
+                };
+                writer.WriteValue(batchHeader);
+
                 var reader = new FastBufferReader(writer, Allocator.Temp);
                 using (reader)
                 {
@@ -149,11 +160,11 @@ namespace Unity.Netcode.EditorTests
         }
 
         [Test]
-        public void WhenReceivingAMessageAndProcessingMessageQueue_ReceiveMethodIsCalled()
+        public unsafe void WhenReceivingAMessageAndProcessingMessageQueue_ReceiveMethodIsCalled()
         {
             var batchHeader = new BatchHeader
             {
-                BatchSize = 1
+                BatchCount = 1
             };
             var messageHeader = new MessageHeader
             {
@@ -170,6 +181,17 @@ namespace Unity.Netcode.EditorTests
                 BytePacker.WriteValueBitPacked(writer, messageHeader.MessageSize);
                 writer.WriteValueSafe(message);
 
+                // Fill out the rest of the batch header
+                writer.Seek(0);
+                batchHeader = new BatchHeader
+                {
+                    Magic = BatchHeader.MagicValue,
+                    BatchSize = writer.Length,
+                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
+                    BatchCount = 1
+                };
+                writer.WriteValue(batchHeader);
+
                 var reader = new FastBufferReader(writer, Allocator.Temp);
                 using (reader)
                 {
@@ -184,11 +206,11 @@ namespace Unity.Netcode.EditorTests
         }
 
         [Test]
-        public void WhenReceivingMultipleMessagesAndProcessingMessageQueue_ReceiveMethodIsCalledMultipleTimes()
+        public unsafe void WhenReceivingMultipleMessagesAndProcessingMessageQueue_ReceiveMethodIsCalledMultipleTimes()
         {
             var batchHeader = new BatchHeader
             {
-                BatchSize = 2
+                BatchCount = 2
             };
             var messageHeader = new MessageHeader
             {
@@ -209,6 +231,17 @@ namespace Unity.Netcode.EditorTests
                 BytePacker.WriteValueBitPacked(writer, messageHeader.MessageSize);
                 writer.WriteValueSafe(message2);
 
+                // Fill out the rest of the batch header
+                writer.Seek(0);
+                batchHeader = new BatchHeader
+                {
+                    Magic = BatchHeader.MagicValue,
+                    BatchSize = writer.Length,
+                    BatchHash = XXHash.Hash64(writer.GetUnsafePtr() + sizeof(BatchHeader), writer.Length - sizeof(BatchHeader)),
+                    BatchCount = 2
+                };
+                writer.WriteValue(batchHeader);
+
                 var reader = new FastBufferReader(writer, Allocator.Temp);
                 using (reader)
                 {

Tests/Editor/Messaging/MessageRegistrationTests.cs

@@ -222,10 +222,11 @@ namespace Unity.Netcode.EditorTests
             {
                 var listMessages = new List<MessagingSystem.MessageWithHandler>();
 
-                var messageWithHandler = new MessagingSystem.MessageWithHandler();
+                var messageWithHandler = new MessagingSystem.MessageWithHandler
-
+                {
-                messageWithHandler.MessageType = typeof(zzzLateLexicographicNetworkMessage);
+                    MessageType = typeof(zzzLateLexicographicNetworkMessage),
-                messageWithHandler.GetVersion = MessagingSystem.CreateMessageAndGetVersion<zzzLateLexicographicNetworkMessage>;
+                    GetVersion = MessagingSystem.CreateMessageAndGetVersion<zzzLateLexicographicNetworkMessage>
+                };
                 listMessages.Add(messageWithHandler);
 
                 messageWithHandler.MessageType = typeof(ConnectionRequestMessage);

Tests/Editor/Messaging/MessageSendingTests.cs

@@ -155,7 +155,7 @@ namespace Unity.Netcode.EditorTests
         {
             var message = GetMessage();
             var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
-            for (var i = 0; i < 1300 / size; ++i)
+            for (var i = 0; i < (1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size; ++i)
             {
                 m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
             }
@@ -169,7 +169,7 @@ namespace Unity.Netcode.EditorTests
         {
             var message = GetMessage();
             var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
-            for (var i = 0; i < (1300 / size) + 1; ++i)
+            for (var i = 0; i < ((1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size) + 1; ++i)
             {
                 m_MessagingSystem.SendMessage(ref message, NetworkDelivery.Reliable, m_Clients);
             }
@@ -183,7 +183,7 @@ namespace Unity.Netcode.EditorTests
         {
             var message = GetMessage();
             var size = UnsafeUtility.SizeOf<TestMessage>() + 2; // MessageHeader packed with this message will be 2 bytes
-            for (var i = 0; i < (1300 / size) + 1; ++i)
+            for (var i = 0; i < ((1300 - UnsafeUtility.SizeOf<BatchHeader>()) / size) + 1; ++i)
             {
                 m_MessagingSystem.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, m_Clients);
             }
@@ -229,7 +229,7 @@ namespace Unity.Netcode.EditorTests
             using (reader)
             {
                 reader.ReadValueSafe(out BatchHeader header);
-                Assert.AreEqual(2, header.BatchSize);
+                Assert.AreEqual(2, header.BatchCount);
 
                 MessageHeader messageHeader;
 

Tests/Editor/Messaging/MessageVersioningTests.cs

@@ -149,7 +149,7 @@ namespace Unity.Netcode.EditorTests
                     var v1 = new VersionedTestMessage_v1();
                     v1.Deserialize(reader, ref context, receivedMessageVersion);
                     A = v1.A;
-                    D = (float)v1.D;
+                    D = v1.D;
                     E = k_DefaultE;
                     Upgraded = true;
                     return true;

Tests/Editor/NetworkManagerConfigurationTests.cs

@@ -1,7 +1,9 @@
+using System.Collections.Generic;
 using NUnit.Framework;
-using UnityEngine;
 using Unity.Netcode.Editor;
+using Unity.Netcode.Transports.UTP;
 using UnityEditor.SceneManagement;
+using UnityEngine;
 using UnityEngine.SceneManagement;
 using UnityEngine.TestTools;
 
@@ -105,12 +107,203 @@ namespace Unity.Netcode.EditorTests
             networkManager.OnValidate();
 
             // Expect a warning
-            LogAssert.Expect(LogType.Warning, $"[Netcode] {NetworkManager.PrefabDebugHelper(networkManager.NetworkConfig.NetworkPrefabs[0])} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)");
+            LogAssert.Expect(LogType.Warning, $"[Netcode] {NetworkManager.PrefabDebugHelper(networkManager.NetworkConfig.Prefabs.Prefabs[0])} has child {nameof(NetworkObject)}(s) but they will not be spawned across the network (unsupported {nameof(NetworkPrefab)} setup)");
 
             // Clean up
             Object.DestroyImmediate(networkManagerObject);
             Object.DestroyImmediate(parent);
 
         }
+
+        [Test]
+        public void WhenNetworkConfigContainsOldPrefabList_TheyMigrateProperlyToTheNewList()
+        {
+            var networkConfig = new NetworkConfig();
+
+            var regularPrefab = new GameObject("Regular Prefab").AddComponent<NetworkObject>();
+            var overriddenPrefab = new GameObject("Overridden Prefab").AddComponent<NetworkObject>();
+            var overridingTargetPrefab = new GameObject("Overriding Target Prefab").AddComponent<NetworkObject>();
+            var sourcePrefabToOverride = new GameObject("Overriding Source Prefab").AddComponent<NetworkObject>();
+
+            regularPrefab.GlobalObjectIdHash = 1;
+            overriddenPrefab.GlobalObjectIdHash = 2;
+            overridingTargetPrefab.GlobalObjectIdHash = 3;
+            sourcePrefabToOverride.GlobalObjectIdHash = 4;
+
+            networkConfig.OldPrefabList = new List<NetworkPrefab>
+            {
+                new NetworkPrefab { Prefab = regularPrefab.gameObject },
+                new NetworkPrefab { Prefab = overriddenPrefab.gameObject, Override = NetworkPrefabOverride.Prefab, OverridingTargetPrefab = overridingTargetPrefab.gameObject, SourcePrefabToOverride = sourcePrefabToOverride.gameObject, SourceHashToOverride = 123456 }
+            };
+
+            networkConfig.InitializePrefabs();
+
+            Assert.IsNull(networkConfig.OldPrefabList);
+            Assert.IsNotNull(networkConfig.Prefabs);
+            Assert.IsNotNull(networkConfig.Prefabs.Prefabs);
+            Assert.AreEqual(2, networkConfig.Prefabs.Prefabs.Count);
+
+            Assert.AreSame(regularPrefab.gameObject, networkConfig.Prefabs.Prefabs[0].Prefab);
+            Assert.AreEqual(NetworkPrefabOverride.None, networkConfig.Prefabs.Prefabs[0].Override);
+            Assert.IsNull(networkConfig.Prefabs.Prefabs[0].SourcePrefabToOverride);
+            Assert.IsNull(networkConfig.Prefabs.Prefabs[0].OverridingTargetPrefab);
+
+            Assert.AreSame(overriddenPrefab.gameObject, networkConfig.Prefabs.Prefabs[1].Prefab);
+            Assert.AreEqual(NetworkPrefabOverride.Prefab, networkConfig.Prefabs.Prefabs[1].Override);
+            Assert.AreEqual(123456, networkConfig.Prefabs.Prefabs[1].SourceHashToOverride);
+            Assert.AreSame(sourcePrefabToOverride.gameObject, networkConfig.Prefabs.Prefabs[1].SourcePrefabToOverride);
+            Assert.AreSame(overridingTargetPrefab.gameObject, networkConfig.Prefabs.Prefabs[1].OverridingTargetPrefab);
+        }
+
+        [Test]
+        public void WhenModifyingPrefabListUsingNetworkManagerAPI_ModificationIsLocal()
+        {
+            // Setup
+            var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager = networkManagerObject.AddComponent<NetworkManager>();
+            networkManager.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
+            networkManager2.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var object1 = new GameObject("Object 1").AddComponent<NetworkObject>();
+
+            var object2 = new GameObject("Object 2").AddComponent<NetworkObject>();
+            var object3 = new GameObject("Object 3").AddComponent<NetworkObject>();
+
+            object1.GlobalObjectIdHash = 1;
+            object2.GlobalObjectIdHash = 2;
+            object3.GlobalObjectIdHash = 3;
+
+            var sharedList = ScriptableObject.CreateInstance<NetworkPrefabsList>();
+            sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject });
+
+            networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+            networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+
+            networkManager.Initialize(true);
+            networkManager2.Initialize(false);
+
+            networkManager.AddNetworkPrefab(object2.gameObject);
+            networkManager2.AddNetworkPrefab(object3.gameObject);
+
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsFalse(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject));
+            Assert.IsFalse(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject));
+
+            Assert.IsTrue(sharedList.Contains(object1.gameObject));
+            Assert.IsFalse(sharedList.Contains(object2.gameObject));
+            Assert.IsFalse(sharedList.Contains(object3.gameObject));
+        }
+
+        [Test]
+        public void WhenModifyingPrefabListUsingPrefabsAPI_ModificationIsLocal()
+        {
+            // Setup
+            var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager = networkManagerObject.AddComponent<NetworkManager>();
+            networkManager.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
+            networkManager2.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var object1 = new GameObject("Object 1").AddComponent<NetworkObject>();
+            var object2 = new GameObject("Object 2").AddComponent<NetworkObject>();
+            var object3 = new GameObject("Object 3").AddComponent<NetworkObject>();
+
+            object1.GlobalObjectIdHash = 1;
+            object2.GlobalObjectIdHash = 2;
+            object3.GlobalObjectIdHash = 3;
+
+            var sharedList = ScriptableObject.CreateInstance<NetworkPrefabsList>();
+            sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject });
+
+            networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+            networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+
+            networkManager.Initialize(true);
+            networkManager2.Initialize(false);
+
+            networkManager.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object2.gameObject });
+            networkManager2.NetworkConfig.Prefabs.Add(new NetworkPrefab { Prefab = object3.gameObject });
+
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsFalse(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject));
+            Assert.IsFalse(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject));
+
+            Assert.IsTrue(sharedList.Contains(object1.gameObject));
+            Assert.IsFalse(sharedList.Contains(object2.gameObject));
+            Assert.IsFalse(sharedList.Contains(object3.gameObject));
+        }
+
+        [Test]
+        public void WhenModifyingPrefabListUsingPrefabsListAPI_ModificationIsShared()
+        {
+            // Setup
+            var networkManagerObject = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager = networkManagerObject.AddComponent<NetworkManager>();
+            networkManager.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var networkManagerObject2 = new GameObject(nameof(NestedNetworkObjectPrefabCheck));
+            var networkManager2 = networkManagerObject2.AddComponent<NetworkManager>();
+            networkManager2.NetworkConfig = new NetworkConfig
+            {
+                NetworkTransport = networkManager.gameObject.AddComponent<UnityTransport>()
+            };
+
+            var object1 = new GameObject("Object 1").AddComponent<NetworkObject>();
+            var object2 = new GameObject("Object 2").AddComponent<NetworkObject>();
+            var object3 = new GameObject("Object 3").AddComponent<NetworkObject>();
+
+            object1.GlobalObjectIdHash = 1;
+            object2.GlobalObjectIdHash = 2;
+            object3.GlobalObjectIdHash = 3;
+
+            var sharedList = ScriptableObject.CreateInstance<NetworkPrefabsList>();
+            sharedList.List.Add(new NetworkPrefab { Prefab = object1.gameObject });
+
+            networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+            networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { sharedList };
+
+            networkManager.Initialize(true);
+            networkManager2.Initialize(false);
+
+            networkManager.NetworkConfig.Prefabs.NetworkPrefabsLists[0].Add(new NetworkPrefab { Prefab = object2.gameObject });
+            networkManager2.NetworkConfig.Prefabs.NetworkPrefabsLists[0].Add(new NetworkPrefab { Prefab = object3.gameObject });
+
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object1.gameObject));
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object2.gameObject));
+            Assert.IsTrue(networkManager2.NetworkConfig.Prefabs.Contains(object3.gameObject));
+            Assert.IsTrue(networkManager.NetworkConfig.Prefabs.Contains(object3.gameObject));
+
+            Assert.IsTrue(sharedList.Contains(object1.gameObject));
+            Assert.IsTrue(sharedList.Contains(object2.gameObject));
+            Assert.IsTrue(sharedList.Contains(object3.gameObject));
+        }
     }
 }

Tests/Editor/NetworkPrefabProcessorTests.cs

@@ -0,0 +1,90 @@
+using NUnit.Framework;
+using Unity.Netcode.Editor.Configuration;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode.EditorTests
+{
+    public class NetworkPrefabProcessorTests
+    {
+        private NetcodeForGameObjectsProjectSettings m_Settings;
+        private bool m_EditorDefaultPrefabSetting;
+        private string m_EditorDefaultPrefabLocation;
+
+        private GameObject m_Prefab;
+
+        private const string k_PrefabName = "Assets/TestPrefab.prefab";
+        private const string k_DefaultAssetString = "Assets/TestPrefabList.asset";
+
+        [SetUp]
+        public void SetUp()
+        {
+            m_Settings = NetcodeForGameObjectsProjectSettings.instance;
+            m_EditorDefaultPrefabSetting = m_Settings.GenerateDefaultNetworkPrefabs;
+            m_EditorDefaultPrefabLocation = NetworkPrefabProcessor.DefaultNetworkPrefabsPath;
+            NetworkPrefabProcessor.DefaultNetworkPrefabsPath = k_DefaultAssetString;
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            m_Settings.GenerateDefaultNetworkPrefabs = m_EditorDefaultPrefabSetting;
+            NetworkPrefabProcessor.DefaultNetworkPrefabsPath = m_EditorDefaultPrefabLocation;
+            AssetDatabase.DeleteAsset(k_PrefabName);
+            AssetDatabase.DeleteAsset(k_DefaultAssetString);
+        }
+
+        [Test]
+        public void WhenGenerateDefaultNetworkPrefabsIsEnabled_AddingAPrefabUpdatesDefaultPrefabList()
+        {
+            var obj = new GameObject("Object");
+            obj.AddComponent<NetworkObject>();
+            m_Settings.GenerateDefaultNetworkPrefabs = true;
+            m_Prefab = PrefabUtility.SaveAsPrefabAsset(obj, k_PrefabName);
+            Object.DestroyImmediate(obj);
+
+            var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false);
+            Assert.IsFalse(isNew);
+            Assert.IsTrue(prefabList.Contains(m_Prefab));
+        }
+
+        [Test]
+        public void WhenGenerateDefaultNetworkPrefabsIsEnabled_RemovingAPrefabUpdatesDefaultPrefabList()
+        {
+            WhenGenerateDefaultNetworkPrefabsIsEnabled_AddingAPrefabUpdatesDefaultPrefabList();
+
+            AssetDatabase.DeleteAsset(k_PrefabName);
+            var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false);
+            Assert.IsFalse(isNew);
+            Assert.IsFalse(prefabList.Contains(m_Prefab));
+        }
+
+        [Test]
+        public void WhenGenerateDefaultNetworkPrefabsIsNotEnabled_AddingAPrefabDoesNotUpdateDefaultPrefabList()
+        {
+            var obj = new GameObject("Object");
+            obj.AddComponent<NetworkObject>();
+            m_Settings.GenerateDefaultNetworkPrefabs = false;
+            m_Prefab = PrefabUtility.SaveAsPrefabAsset(obj, k_PrefabName);
+            Object.DestroyImmediate(obj);
+
+            var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false);
+            Assert.IsTrue(isNew);
+            Assert.IsFalse(prefabList.Contains(m_Prefab));
+        }
+
+        [Test]
+        public void WhenGenerateDefaultNetworkPrefabsIsNotEnabled_RemovingAPrefabDoesNotUpdateDefaultPrefabList()
+        {
+            // Add it with the list enabled, then disable the list. Removing it
+            // should then be nop.
+            WhenGenerateDefaultNetworkPrefabsIsEnabled_AddingAPrefabUpdatesDefaultPrefabList();
+
+            m_Settings.GenerateDefaultNetworkPrefabs = false;
+            AssetDatabase.DeleteAsset(k_PrefabName);
+            var prefabList = NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out var isNew, false);
+            Assert.IsFalse(isNew);
+            Assert.IsTrue(prefabList.Contains(m_Prefab));
+        }
+    }
+}

Tests/Editor/NetworkPrefabProcessorTests.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 6471efe05b0548ef9d2171e07d4a561b
+timeCreated: 1669140101

Tests/Editor/Serialization/BaseFastBufferReaderWriterTest.cs

@@ -7,8 +7,6 @@ namespace Unity.Netcode.EditorTests
 {
     public abstract class BaseFastBufferReaderWriterTest
     {
-
-        #region Test Types
         protected enum ByteEnum : byte
         {
             A,
@@ -78,7 +76,6 @@ namespace Unity.Netcode.EditorTests
             WriteDirect,
             WriteSafe
         }
-        #endregion
 
         protected abstract void RunTypeTest<T>(T valueToTest) where T : unmanaged;
 
@@ -88,7 +85,6 @@ namespace Unity.Netcode.EditorTests
 
         protected abstract void RunTypeArrayTestSafe<T>(T[] valueToTest) where T : unmanaged;
 
-        #region Helpers
         protected TestStruct GetTestStruct()
         {
             var random = new Random();
@@ -98,7 +94,7 @@ namespace Unity.Netcode.EditorTests
                 A = (byte)random.Next(),
                 B = (short)random.Next(),
                 C = (ushort)random.Next(),
-                D = (int)random.Next(),
+                D = random.Next(),
                 E = (uint)random.Next(),
                 F = ((long)random.Next() << 32) + random.Next(),
                 G = ((ulong)random.Next() << 32) + (ulong)random.Next(),
@@ -111,9 +107,6 @@ namespace Unity.Netcode.EditorTests
             return testStruct;
         }
 
-        #endregion
-
-
         private void RunTestWithWriteType<T>(T val, WriteType wt, FastBufferWriter.ForPrimitives _ = default) where T : unmanaged
         {
             switch (wt)
@@ -149,7 +142,7 @@ namespace Unity.Netcode.EditorTests
             }
             else if (testType == typeof(int))
             {
-                RunTestWithWriteType((int)random.Next(), writeType);
+                RunTestWithWriteType(random.Next(), writeType);
             }
             else if (testType == typeof(uint))
             {
@@ -354,10 +347,10 @@ namespace Unity.Netcode.EditorTests
             else if (testType == typeof(long))
             {
                 RunTypeTestLocal(new[]{
-                    ((long)random.Next() << 32) + (long)random.Next(),
+                    ((long)random.Next() << 32) + random.Next(),
-                    ((long)random.Next() << 32) + (long)random.Next(),
+                    ((long)random.Next() << 32) + random.Next(),
-                    ((long)random.Next() << 32) + (long)random.Next(),
+                    ((long)random.Next() << 32) + random.Next(),
-                    ((long)random.Next() << 32) + (long)random.Next()
+                    ((long)random.Next() << 32) + random.Next()
                 }, writeType);
             }
             else if (testType == typeof(ulong))

Tests/Editor/Serialization/BytePackerTests.cs

@@ -10,8 +10,6 @@ namespace Unity.Netcode.EditorTests
 {
     public class BytePackerTests
     {
-        #region Test Types
-
         private enum ByteEnum : byte
         {
             A,
@@ -74,8 +72,6 @@ namespace Unity.Netcode.EditorTests
             WriteAsObject
         }
 
-        #endregion
-
         private unsafe void VerifyBytewiseEquality<T>(T value, T otherValue) where T : unmanaged
         {
             byte* asBytePointer = (byte*)&value;

Tests/Editor/Serialization/FastBufferReaderTests.cs

@@ -9,7 +9,6 @@ namespace Unity.Netcode.EditorTests
 {
     public class FastBufferReaderTests : BaseFastBufferReaderWriterTest
     {
-        #region Common Checks
         private void WriteCheckBytes(FastBufferWriter writer, int writeSize, string failMessage = "")
         {
             Assert.IsTrue(writer.TryBeginWrite(2), "Writer denied write permission");
@@ -230,9 +229,7 @@ namespace Unity.Netcode.EditorTests
             method.Invoke(reader, args);
             value = (T[])args[0];
         }
-        #endregion
 
-        #region Generic Checks
         protected override unsafe void RunTypeTest<T>(T valueToTest)
         {
             var writeSize = FastBufferWriter.GetWriteSize(valueToTest);
@@ -343,9 +340,6 @@ namespace Unity.Netcode.EditorTests
             }
         }
 
-        #endregion
-
-        #region Tests
         [Test]
         public void GivenFastBufferWriterContainingValue_WhenReadingUnmanagedType_ValueMatchesWhatWasWritten(
             [Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
@@ -1220,7 +1214,5 @@ namespace Unity.Netcode.EditorTests
                 Assert.AreEqual(reader.Handle->AllowedReadMark, 25);
             }
         }
-
-        #endregion
     }
 }

Tests/Editor/Serialization/FastBufferWriterTests.cs

@@ -9,9 +9,6 @@ namespace Unity.Netcode.EditorTests
 {
     public class FastBufferWriterTests : BaseFastBufferReaderWriterTest
     {
-
-        #region Common Checks
-
         private void WriteCheckBytes(FastBufferWriter writer, int writeSize, string failMessage = "")
         {
             Assert.IsTrue(writer.TryBeginWrite(2), "Writer denied write permission");
@@ -66,10 +63,6 @@ namespace Unity.Netcode.EditorTests
             VerifyTypedEquality(valueToTest, writer.GetUnsafePtr());
         }
 
-        #endregion
-
-        #region Generic Checks
-
         private void RunMethod<T>(string methodName, FastBufferWriter writer, in T value) where T : unmanaged
         {
             MethodInfo method = typeof(FastBufferWriter).GetMethod(methodName, new[] { typeof(T).MakeByRefType() });
@@ -248,11 +241,8 @@ namespace Unity.Netcode.EditorTests
                 VerifyCheckBytes(underlyingArray, writeSize);
             }
         }
-        #endregion
 
-
+        [Test, Description("Tests")]
-        #region Tests
-        [Test, Description("Tests ")]
         public void WhenWritingUnmanagedType_ValueIsWrittenCorrectly(
             [Values(typeof(byte), typeof(sbyte), typeof(short), typeof(ushort), typeof(int), typeof(uint),
                 typeof(long), typeof(ulong), typeof(bool), typeof(char), typeof(float), typeof(double),
@@ -1317,6 +1307,5 @@ namespace Unity.Netcode.EditorTests
                 Assert.AreEqual(writer.Handle->AllowedWriteMark, 25);
             }
         }
-        #endregion
     }
 }

Tests/Editor/Transports/BatchedReceiveQueueTests.cs

@@ -28,7 +28,7 @@ namespace Unity.Netcode.EditorTests
 
             var writer = new DataStreamWriter(data);
             writer.WriteInt(1);
-            writer.WriteByte((byte)42);
+            writer.WriteByte(42);
 
             var reader = new DataStreamReader(data);
             var q = new BatchedReceiveQueue(reader);
@@ -52,9 +52,9 @@ namespace Unity.Netcode.EditorTests
 
             var writer = new DataStreamWriter(data);
             writer.WriteInt(1);
-            writer.WriteByte((byte)42);
+            writer.WriteByte(42);
             writer.WriteInt(1);
-            writer.WriteByte((byte)142);
+            writer.WriteByte(142);
 
             var reader = new DataStreamReader(data);
             var q = new BatchedReceiveQueue(reader);
@@ -132,7 +132,7 @@ namespace Unity.Netcode.EditorTests
 
             var writer = new DataStreamWriter(data);
             writer.WriteInt(1);
-            writer.WriteByte((byte)42);
+            writer.WriteByte(42);
 
             var reader = new DataStreamReader(data);
             var q = new BatchedReceiveQueue(reader);
@@ -168,7 +168,7 @@ namespace Unity.Netcode.EditorTests
 
             var writer = new DataStreamWriter(data);
             writer.WriteInt(1);
-            writer.WriteByte((byte)42);
+            writer.WriteByte(42);
 
             var reader = new DataStreamReader(data);
             var q = new BatchedReceiveQueue(reader);