com.unity.netcode.gameobjects@2.0.0-pre.2

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).

## [2.0.0-pre.2] - 2024-06-17

### Added

- Added `AnticipatedNetworkVariable<T>`, which adds support for client anticipation of `NetworkVariable` values, allowing for more responsive gameplay. (#2957)
- Added `AnticipatedNetworkTransform`, which adds support for client anticipation of NetworkTransforms. (#2957)
- Added `NetworkVariableBase.ExceedsDirtinessThreshold` to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in `NetworkVariable<T>` with the callback `NetworkVariable<T>.CheckExceedsDirtinessThreshold`). (#2957)
- Added `NetworkVariableUpdateTraits`, which add additional throttling support: `MinSecondsBetweenUpdates` will prevent the `NetworkVariable` from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while `MaxSecondsBetweenUpdates` will force a dirty `NetworkVariable` to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2957)
- Added virtual method `NetworkVariableBase.OnInitialize` which can be used by `NetworkVariable` subclasses to add initialization code. (#2957)
- Added `NetworkTime.TickWithPartial`, which represents the current tick as a double that includes the fractional/partial tick value. (#2957)
- Added `NetworkTickSystem.AnticipationTick`, which can be helpful with implementation of client anticipation. This value represents the tick the current local client was at at the beginning of the most recent network round trip, which enables it to correlate server update ticks with the client tick that may have triggered them. (#2957)
- Added event `NetworkManager.OnSessionOwnerPromoted` that is invoked when a new session owner promotion occurs. (#2948)
- Added `NetworkRigidBodyBase.GetLinearVelocity` and `NetworkRigidBodyBase.SetLinearVelocity` convenience/helper methods. (#2948)
- Added `NetworkRigidBodyBase.GetAngularVelocity` and `NetworkRigidBodyBase.SetAngularVelocity` convenience/helper methods. (#2948)

### Fixed

- Fixed issue when `NetworkTransform` half float precision is enabled and ownership changes the current base position was not being synchronized. (#2948)
- Fixed issue where `OnClientConnected` not being invoked on the session owner when connecting to a new distributed authority session. (#2948)
- Fixed issue where Rigidbody micro-motion (i.e. relatively small velocities) would result in non-authority instances slightly stuttering as the body would come to a rest (i.e. no motion). Now, the threshold value can increase at higher velocities and can decrease slightly below the provided threshold to account for this. (#2948)

### Changed

- Changed `NetworkAnimator` no longer requires the `Animator` component to exist on the same `GameObject`. (#2957)
- Changed `NetworkObjectReference` and `NetworkBehaviourReference` to allow null references when constructing and serializing. (#2957)
- Changed the client's owned objects is now returned (`NetworkClient` and `NetworkSpawnManager`) as an array as opposed to a list for performance purposes. (#2948)
- Changed `NetworkTransfrom.TryCommitTransformToServer` to be internal as it will be removed by the final 2.0.0 release. (#2948)
- Changed `NetworkTransformEditor.OnEnable` to a virtual method to be able to customize a `NetworkTransform` derived class by creating a derived editor control from `NetworkTransformEditor`. (#2948)

CHANGELOG.md

@@ -6,6 +6,73 @@ 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).
 
+## [2.0.0-pre.2] - 2024-06-17
+
+### Added
+
+- Added `AnticipatedNetworkVariable<T>`, which adds support for client anticipation of `NetworkVariable` values, allowing for more responsive gameplay. (#2957)
+- Added `AnticipatedNetworkTransform`, which adds support for client anticipation of NetworkTransforms. (#2957)
+- Added `NetworkVariableBase.ExceedsDirtinessThreshold` to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in `NetworkVariable<T>` with the callback `NetworkVariable<T>.CheckExceedsDirtinessThreshold`). (#2957)
+- Added `NetworkVariableUpdateTraits`, which add additional throttling support: `MinSecondsBetweenUpdates` will prevent the `NetworkVariable` from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while `MaxSecondsBetweenUpdates` will force a dirty `NetworkVariable` to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2957)
+- Added virtual method `NetworkVariableBase.OnInitialize` which can be used by `NetworkVariable` subclasses to add initialization code. (#2957)
+- Added `NetworkTime.TickWithPartial`, which represents the current tick as a double that includes the fractional/partial tick value. (#2957)
+- Added `NetworkTickSystem.AnticipationTick`, which can be helpful with implementation of client anticipation. This value represents the tick the current local client was at at the beginning of the most recent network round trip, which enables it to correlate server update ticks with the client tick that may have triggered them. (#2957)
+- Added event `NetworkManager.OnSessionOwnerPromoted` that is invoked when a new session owner promotion occurs. (#2948)
+- Added `NetworkRigidBodyBase.GetLinearVelocity` and `NetworkRigidBodyBase.SetLinearVelocity` convenience/helper methods. (#2948)
+- Added `NetworkRigidBodyBase.GetAngularVelocity` and `NetworkRigidBodyBase.SetAngularVelocity` convenience/helper methods. (#2948)
+
+### Fixed
+
+- Fixed issue when `NetworkTransform` half float precision is enabled and ownership changes the current base position was not being synchronized. (#2948)
+- Fixed issue where `OnClientConnected` not being invoked on the session owner when connecting to a new distributed authority session. (#2948)
+- Fixed issue where Rigidbody micro-motion (i.e. relatively small velocities) would result in non-authority instances slightly stuttering as the body would come to a rest (i.e. no motion). Now, the threshold value can increase at higher velocities and can decrease slightly below the provided threshold to account for this. (#2948)
+
+### Changed
+
+- Changed `NetworkAnimator` no longer requires the `Animator` component to exist on the same `GameObject`. (#2957)
+- Changed `NetworkObjectReference` and `NetworkBehaviourReference` to allow null references when constructing and serializing. (#2957)
+- Changed the client's owned objects is now returned (`NetworkClient` and `NetworkSpawnManager`) as an array as opposed to a list for performance purposes. (#2948)
+- Changed `NetworkTransfrom.TryCommitTransformToServer` to be internal as it will be removed by the final 2.0.0 release. (#2948)
+- Changed `NetworkTransformEditor.OnEnable` to a virtual method to be able to customize a `NetworkTransform` derived class by creating a derived editor control from `NetworkTransformEditor`. (#2948)
+
+
+## [2.0.0-exp.5] - 2024-06-03
+
+### Added
+
+
+### Fixed
+
+- Fixed issue where SessionOwner message was being treated as a new entry for the new message indexing when it should have been ordinally sorted with the legacy message indices. (#2942)
+
+### Changed
+- Changed `FastBufferReader` and `FastBufferWriter` so that they always ensure the length of items serialized is always serialized as an `uint` and added a check before casting for safe reading and writing.(#2946)
+
+
+## [2.0.0-exp.4] - 2024-05-31
+
+### Added
+
+- Added `NetworkRigidbodyBase.AttachToFixedJoint` and `NetworkRigidbodyBase.DetachFromFixedJoint` to replace parenting for rigid bodies that have `NetworkRigidbodyBase.UseRigidBodyForMotion` enabled. (#2933)
+- Added `NetworkBehaviour.OnNetworkPreSpawn` and `NetworkBehaviour.OnNetworkPostSpawn` methods that provide the ability to handle pre and post spawning actions during the `NetworkObject` spawn sequence. (#2912)
+- Added a client-side only `NetworkBehaviour.OnNetworkSessionSynchronized` convenience method that is invoked on all `NetworkBehaviour`s after a newly joined client has finished synchronizing with the network session in progress. (#2912)
+- Added `NetworkBehaviour.OnInSceneObjectsSpawned` convenience method that is invoked when all in-scene `NetworkObject`s have been spawned after a scene has been loaded or upon a host or server starting. (#2912)
+
+### Fixed
+
+- Fixed issue where non-authoritative rigid bodies with `NetworkRigidbodyBase.UseRigidBodyForMotion` enabled would constantly log errors about the renderTime being before `StartTimeConsumed`. (#2933)
+- Fixed issue where in-scene placed NetworkObjects could be destroyed if a client disconnects early and/or before approval. (#2924)
+- Fixed issue where a `NetworkObject` component's associated `NetworkBehaviour` components would not be detected if scene loading is disabled in the editor and the currently loaded scene has in-scene placed `NetworkObject`s. (#2912)
+- Fixed issue where an in-scene placed `NetworkObject` with `NetworkTransform` that is also parented under a `GameObject` would not properly synchronize when the parent `GameObject` had a world space position other than 0,0,0. (#2898)
+
+### Changed
+
+- Change all the access modifiers of test class from Public to Internal (#2930)
+- Changed messages are now sorted by enum values as opposed to ordinally sorting the messages by their type name. (#2929)
+- Changed `NetworkClient.SessionModeTypes` to `NetworkClient.NetworkTopologyTypes`. (#2875)
+- Changed `NetworkClient.SessionModeType` to `NetworkClient.NetworkTopologyType`. (#2875)
+- Changed `NetworkConfig.SessionMode` to `NeworkConfig.NetworkTopology`. (#2875)
+
 ## [2.0.0-exp.2] - 2024-04-02
 
 ### Added
@@ -52,7 +119,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Added distributed authority mode specific `NetworkObject.OnDeferredDespawnComplete` callback handler that can be used to further control when deferring the despawning of a `NetworkObject` on non-authoritative instances. (#2863)
 - Added `NetworkClient.SessionModeType` as one way to determine the current session mode of the network session a client is connected to. (#2863)
 - Added distributed authority mode specific `NetworkClient.IsSessionOwner` property to determine if the current local client is the current session owner of a distributed authority session. (#2863)
-- Added distributed authority mode specific client side spawning capabilities. When running in distributed authority mode, clients can instantiate and spawn `NetworkObject` instances (the local client is authomatically the owner of the spawned object). (#2863)
+- Added distributed authority mode specific client side spawning capabilities. When running in distributed authority mode, clients can instantiate and spawn `NetworkObject` instances (the local client is automatically the owner of the spawned object). (#2863)
   - This is useful to better visually synchronize owner authoritative motion models and newly spawned `NetworkObject` instances (i.e. projectiles for example).
 - Added distributed authority mode specific client side player spawning capabilities. Clients will automatically spawn their associated player object locally. (#2863)
 - Added distributed authority mode specific `NetworkConfig.AutoSpawnPlayerPrefabClientSide` property (default is true) to provide control over the automatic spawning of player prefabs on the local client side. (#2863)
@@ -79,6 +146,36 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Changed `NetworkTransform` to now use `NetworkTransformMessage` as opposed to named messages for NetworkTransformState updates. (#2810)
 - Changed `CustomMessageManager` so it no longer attempts to register or "unregister" a null or empty string and will log an error if this condition occurs. (#2807)
 
+## [1.9.1] - 2024-04-18
+
+### Added
+- Added `AnticipatedNetworkVariable<T>`, which adds support for client anticipation of NetworkVariable values, allowing for more responsive game play (#2820)
+- Added `AnticipatedNetworkTransform`, which adds support for client anticipation of `NetworkTransform`s (#2820)
+- Added `NetworkVariableBase.ExceedsDirtinessThreshold` to allow network variables to throttle updates by only sending updates when the difference between the current and previous values exceeds a threshold. (This is exposed in NetworkVariable<T> with the callback NetworkVariable<T>.CheckExceedsDirtinessThreshold) (#2820)
+- Added `NetworkVariableUpdateTraits`, which add additional throttling support: `MinSecondsBetweenUpdates` will prevent the `NetworkVariable` from sending updates more often than the specified time period (even if it exceeds the dirtiness threshold), while `MaxSecondsBetweenUpdates` will force a dirty `NetworkVariable` to send an update after the specified time period even if it has not yet exceeded the dirtiness threshold. (#2820)
+- Added virtual method `NetworkVariableBase.OnInitialize()` which can be used by `NetworkVariable` subclasses to add initialization code (#2820)
+- Added virtual method `NetworkVariableBase.Update()`, which is called once per frame to support behaviors such as interpolation between an anticipated value and an authoritative one. (#2820)
+- Added `NetworkTime.TickWithPartial`, which represents the current tick as a double that includes the fractional/partial tick value. (#2820)
+- `NetworkVariable` now includes built-in support for `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, and `Dictionary` (#2813)
+- `NetworkVariable` now includes delta compression for collection values (`NativeList`, `NativeArray`, `NativeHashSet`, `NativeHashMap`, `List`, `HashSet`, `Dictionary`, and `FixedString` types) to save bandwidth by only sending the values that changed. (Note: For `NativeList`, `NativeArray`, and `List`, this algorithm works differently than that used in `NetworkList`. This algorithm will use less bandwidth for "set" and "add" operations, but `NetworkList` is more bandwidth-efficient if you are performing frequent "insert" operations.) (#2813)
+- `UserNetworkVariableSerialization` now has optional callbacks for `WriteDelta` and `ReadDelta`. If both are provided, they will be used for all serialization operations on NetworkVariables of that type except for the first one for each client. If either is missing, the existing `Write` and `Read` will always be used. (#2813)
+- Network variables wrapping `INetworkSerializable` types can perform delta serialization by setting `UserNetworkVariableSerialization<T>.WriteDelta` and `UserNetworkVariableSerialization<T>.ReadDelta` for those types. The built-in `INetworkSerializable` serializer will continue to be used for all other serialization operations, but if those callbacks are set, it will call into them on all but the initial serialization to perform delta serialization. (This could be useful if you have a large struct where most values do not change regularly and you want to send only the fields that did change.) (#2813)
+
+### Fixed
+
+- Fixed issue where `NetworkTransformEditor` would throw and exception if you excluded the physics package. (#2871)
+- Fixed issue where `NetworkTransform` could not properly synchronize its base position when using half float precision. (#2845)
+- Fixed issue where the host was not invoking `OnClientDisconnectCallback` for its own local client when internally shutting down. (#2822)
+- Fixed issue where NetworkTransform could potentially attempt to "unregister" a named message prior to it being registered. (#2807)
+- Fixed issue where in-scene placed `NetworkObject`s with complex nested children `NetworkObject`s (more than one child in depth) would not synchronize properly if WorldPositionStays was set to true. (#2796)
+
+### Changed
+
+- Changed `NetworkObjectReference` and `NetworkBehaviourReference` to allow null references when constructing and serializing. (#2874)
+- Changed `NetworkAnimator` no longer requires the `Animator` component to exist on the same `GameObject`. (#2872)
+- Changed `NetworkTransform` to now use `NetworkTransformMessage` as opposed to named messages for NetworkTransformState updates. (#2810)
+- Changed `CustomMessageManager` so it no longer attempts to register or "unregister" a null or empty string and will log an error if this condition occurs. (#2807)
+
 ## [1.8.1] - 2024-02-05
 
 ### Fixed

Components/AssemblyInfo.cs

@@ -1,15 +0,0 @@
-using System.Runtime.CompilerServices;
-
-#if UNITY_EDITOR
-[assembly: InternalsVisibleTo("Unity.Netcode.Editor")]
-[assembly: InternalsVisibleTo("Unity.Netcode.Editor.CodeGen")]
-#endif // UNITY_EDITOR
-
-#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/Messages.meta

@@ -1,8 +0,0 @@
-fileFormatVersion: 2
-guid: a9db1d18fa0117f4da5e8e65386b894a
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Components/Messages/NetworkTransformMessage.cs

@@ -1,205 +0,0 @@
-using Unity.Netcode.Components;
-using UnityEngine;
-
-namespace Unity.Netcode
-{
-    /// <summary>
-    /// NetworkTransform State Update Message
-    /// </summary>
-    internal struct NetworkTransformMessage : INetworkMessage
-    {
-        public int Version => 0;
-        public ulong NetworkObjectId;
-        public int NetworkBehaviourId;
-        // This is only used when serializing but not serialized
-        public bool DistributedAuthorityMode;
-        // Might get removed
-        public ulong[] TargetIds;
-
-        private int GetTargetIdLength()
-        {
-            if (TargetIds != null)
-            {
-                return TargetIds.Length;
-            }
-            return 0;
-        }
-
-        public NetworkTransform.NetworkTransformState State;
-
-        private NetworkTransform m_ReceiverNetworkTransform;
-        private FastBufferReader m_CurrentReader;
-
-        private unsafe void CopyPayload(ref FastBufferWriter writer)
-        {
-            writer.WriteBytesSafe(m_CurrentReader.GetUnsafePtrAtCurrentPosition(), m_CurrentReader.Length - m_CurrentReader.Position);
-        }
-
-        public void Serialize(FastBufferWriter writer, int targetVersion)
-        {
-            if (m_CurrentReader.IsInitialized)
-            {
-                CopyPayload(ref writer);
-            }
-            else
-            {
-                BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
-                BytePacker.WriteValueBitPacked(writer, NetworkBehaviourId);
-                writer.WriteNetworkSerializable(State);
-                if (DistributedAuthorityMode)
-                {
-                    var length = GetTargetIdLength();
-                    BytePacker.WriteValuePacked(writer, length);
-                    // If no target ids, then just exit early (DAHost specific)
-                    if (length == 0)
-                    {
-                        return;
-                    }
-                    foreach (var target in TargetIds)
-                    {
-                        BytePacker.WriteValuePacked(writer, target);
-                    }
-                }
-            }
-        }
-
-        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
-        {
-            var networkManager = context.SystemOwner as NetworkManager;
-            if (networkManager == null)
-            {
-                Debug.LogError($"[{nameof(NetworkTransformMessage)}] System owner context was not of type {nameof(NetworkManager)}!");
-                return false;
-            }
-            var currentPosition = reader.Position;
-            ByteUnpacker.ReadValueBitPacked(reader, out NetworkObjectId);
-            var isSpawnedLocally = networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId);
-
-            // Only defer if the NetworkObject is not spawned yet and the local NetworkManager is not running as a DAHost.
-            if (!isSpawnedLocally && !networkManager.DAHost)
-            {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context);
-                return false;
-            }
-
-            // While the below check and assignment might seem out of place, this is specific to running in DAHost mode when a NetworkObject is
-            // hidden from the DAHost but is visible to other clients. Since the DAHost needs to forward updates to the clients, we ignore processing
-            // this message locally
-            var networkObject = (NetworkObject)null;
-            var isServerAuthoritative = false;
-            var ownerAuthoritativeServerSide = false;
-
-            // Get the behaviour index
-            ByteUnpacker.ReadValueBitPacked(reader, out NetworkBehaviourId);
-
-            // Deserialize the state
-            reader.ReadNetworkSerializableInPlace(ref State);
-
-            if (networkManager.DistributedAuthorityMode)
-            {
-                var targetCount = 0;
-                ByteUnpacker.ReadValueBitPacked(reader, out targetCount);
-                if (targetCount > 0)
-                {
-                    TargetIds = new ulong[targetCount];
-                }
-                var targetId = (ulong)0;
-                for (int i = 0; i < targetCount; i++)
-                {
-                    ByteUnpacker.ReadValueBitPacked(reader, out targetId);
-                    TargetIds[i] = targetId;
-                }
-            }
-
-            if (isSpawnedLocally)
-            {
-                networkObject = networkManager.SpawnManager.SpawnedObjects[NetworkObjectId];
-                // Get the target NetworkTransform
-                m_ReceiverNetworkTransform = networkObject.ChildNetworkBehaviours[NetworkBehaviourId] as NetworkTransform;
-                isServerAuthoritative = m_ReceiverNetworkTransform.IsServerAuthoritative();
-                ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
-            }
-            else
-            {
-                // If we are the DAHost and the NetworkObject is hidden from the host we still need to forward this message
-                ownerAuthoritativeServerSide = networkManager.DAHost && !isSpawnedLocally;
-            }
-
-            if (ownerAuthoritativeServerSide)
-            {
-                var ownerClientId = (ulong)0;
-
-                if (networkObject != null)
-                {
-                    ownerClientId = networkObject.OwnerClientId;
-                    if (ownerClientId == NetworkManager.ServerClientId)
-                    {
-                        // Ownership must have changed, ignore any additional pending messages that might have
-                        // come from a previous owner client.
-                        return true;
-                    }
-                }
-                else if (networkManager.DAHost)
-                {
-                    // Specific to distributed authority mode, the only sender of state updates will be the owner 
-                    ownerClientId = context.SenderId;
-                }
-
-                var networkDelivery = State.IsReliableStateUpdate() ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;
-
-                // Forward the state update if there are any remote clients to foward it to
-                if (networkManager.ConnectionManager.ConnectedClientsList.Count > (networkManager.IsHost ? 2 : 1))
-                {
-                    var clientCount = networkManager.DistributedAuthorityMode ? GetTargetIdLength() : networkManager.ConnectionManager.ConnectedClientsList.Count;
-                    if (clientCount == 0)
-                    {
-                        return true;
-                    }
-
-                    // This is only to copy the existing and already serialized struct for forwarding purposes only.
-                    // This will not include any changes made to this struct at this particular stage of processing the message.
-                    var currentMessage = this;
-                    // Create a new reader that replicates this message
-                    currentMessage.m_CurrentReader = new FastBufferReader(reader, Collections.Allocator.None);
-                    // Rewind the new reader to the beginning of the message's payload
-                    currentMessage.m_CurrentReader.Seek(currentPosition);
-                    // Forward the message to all connected clients that are observers of the associated NetworkObject
-
-                    for (int i = 0; i < clientCount; i++)
-                    {
-                        var clientId = networkManager.DistributedAuthorityMode ? TargetIds[i] : networkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
-                        if (NetworkManager.ServerClientId == clientId || (!isServerAuthoritative && clientId == ownerClientId) ||
-                            (!networkManager.DistributedAuthorityMode && !networkObject.Observers.Contains(clientId)))
-                        {
-                            continue;
-                        }
-
-                        networkManager.MessageManager.SendMessage(ref currentMessage, networkDelivery, clientId);
-                    }
-                    // Dispose of the reader used for forwarding
-                    currentMessage.m_CurrentReader.Dispose();
-                }
-            }
-            return true;
-        }
-
-        public void Handle(ref NetworkContext context)
-        {
-            var networkManager = context.SystemOwner as NetworkManager;
-            // Only if the local NetworkManager instance is running as the DAHost we just exit if there is no local
-            // NetworkTransform component to apply the state update to (i.e. it is hidden from the DAHost and it
-            // just forwarded the state update to any other connected client)
-            if (networkManager.DAHost && m_ReceiverNetworkTransform == null)
-            {
-                return;
-            }
-
-            if (m_ReceiverNetworkTransform == null)
-            {
-                Debug.LogError($"[{nameof(NetworkTransformMessage)}][Dropped] Reciever {nameof(NetworkTransform)} was not set!");
-                return;
-            }
-            m_ReceiverNetworkTransform.TransformStateUpdate(ref State, context.SenderId);
-        }
-    }
-}

Components/com.unity.netcode.components.asmdef

@@ -1,27 +0,0 @@
-{
-    "name": "Unity.Netcode.Components",
-    "rootNamespace": "Unity.Netcode.Components",
-    "references": [
-        "Unity.Netcode.Runtime",
-        "Unity.Collections",
-        "Unity.Mathematics"
-    ],
-    "allowUnsafeCode": true,
-    "versionDefines": [
-        {
-            "name": "com.unity.modules.animation",
-            "expression": "",
-            "define": "COM_UNITY_MODULES_ANIMATION"
-        },
-        {
-            "name": "com.unity.modules.physics",
-            "expression": "",
-            "define": "COM_UNITY_MODULES_PHYSICS"
-        },
-        {
-            "name": "com.unity.modules.physics2d",
-            "expression": "",
-            "define": "COM_UNITY_MODULES_PHYSICS2D"
-        }
-    ]
-}

Components/com.unity.netcode.components.asmdef.meta

@@ -1,7 +0,0 @@
-fileFormatVersion: 2
-guid: 3b8ed52f1b5c64994af4c4e0aa4b6c4b
-AssemblyDefinitionImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

Editor/CodeGen/NetworkBehaviourILPP.cs

@@ -27,7 +27,8 @@ namespace Unity.Netcode.Editor.CodeGen
 
         public override ILPPInterface GetInstance() => this;
 
-        public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.References.Any(filePath => Path.GetFileNameWithoutExtension(filePath) == CodeGenHelpers.RuntimeAssemblyName);
+        public override bool WillProcess(ICompiledAssembly compiledAssembly) => compiledAssembly.Name == CodeGenHelpers.RuntimeAssemblyName ||
+            compiledAssembly.References.Any(filePath => Path.GetFileNameWithoutExtension(filePath) == CodeGenHelpers.RuntimeAssemblyName);
 
         private readonly List<DiagnosticMessage> m_Diagnostics = new List<DiagnosticMessage>();
 
@@ -408,6 +409,7 @@ namespace Unity.Netcode.Editor.CodeGen
                     }
                     else
                     {
+                        m_Diagnostics.AddError($"{type}: Managed type in NetworkVariable must implement IEquatable<{type}>");
                         equalityMethod = new GenericInstanceMethod(m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef);
                     }
 
@@ -720,7 +722,7 @@ namespace Unity.Netcode.Editor.CodeGen
                     continue;
                 }
 
-                if (networkVariableSerializationTypesTypeDef == null && netcodeTypeDef.Name == nameof(NetworkVariableSerializationTypes))
+                if (networkVariableSerializationTypesTypeDef == null && netcodeTypeDef.Name == nameof(NetworkVariableSerializationTypedInitializers))
                 {
                     networkVariableSerializationTypesTypeDef = netcodeTypeDef;
                     continue;
@@ -1006,103 +1008,103 @@ namespace Unity.Netcode.Editor.CodeGen
 
                 switch (method.Name)
                 {
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpy):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedByMemcpy):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpy_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpyArray):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedByMemcpyArray):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyArray_MethodRef = method;
                         break;
 
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedByMemcpyList):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedByMemcpyList):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedByMemcpyList_MethodRef = method;
                         break;
 #endif
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializable):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedINetworkSerializable):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializable_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializableArray):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedINetworkSerializableArray):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableArray_MethodRef = method;
                         break;
 
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_UnmanagedINetworkSerializableList):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_UnmanagedINetworkSerializableList):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_UnmanagedINetworkSerializableList_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_NativeHashSet):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_NativeHashSet):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashSet_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_NativeHashMap):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_NativeHashMap):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_NativeHashMap_MethodRef = method;
                         break;
 #endif
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_List):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_List):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_List_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_HashSet):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_HashSet):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_HashSet_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_Dictionary):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_Dictionary):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_Dictionary_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_ManagedINetworkSerializable):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_ManagedINetworkSerializable):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_ManagedINetworkSerializable_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_FixedString):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_FixedString):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_FixedString_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_FixedStringArray):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_FixedStringArray):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringArray_MethodRef = method;
                         break;
 
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
-                    case nameof(NetworkVariableSerializationTypes.InitializeSerializer_FixedStringList):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeSerializer_FixedStringList):
                         m_NetworkVariableSerializationTypes_InitializeSerializer_FixedStringList_MethodRef = method;
                         break;
 #endif
 
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_ManagedIEquatable):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_ManagedIEquatable):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedIEquatable_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatable):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedIEquatable):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatable_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatableArray):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedIEquatableArray):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableArray_MethodRef = method;
                         break;
 
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedIEquatableList):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedIEquatableList):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedIEquatableList_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_NativeHashSet):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_NativeHashSet):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashSet_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_NativeHashMap):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_NativeHashMap):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_NativeHashMap_MethodRef = method;
                         break;
 #endif
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_List):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_List):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_List_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_HashSet):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_HashSet):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_HashSet_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_Dictionary):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_Dictionary):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_Dictionary_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEquals):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedValueEquals):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEquals_MethodRef = method;
                         break;
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEqualsArray):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedValueEqualsArray):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsArray_MethodRef = method;
                         break;
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_UnmanagedValueEqualsList):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_UnmanagedValueEqualsList):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_UnmanagedValueEqualsList_MethodRef = method;
                         break;
 #endif
-                    case nameof(NetworkVariableSerializationTypes.InitializeEqualityChecker_ManagedClassEquals):
+                    case nameof(NetworkVariableSerializationTypedInitializers.InitializeEqualityChecker_ManagedClassEquals):
                         m_NetworkVariableSerializationTypes_InitializeEqualityChecker_ManagedClassEquals_MethodRef = method;
                         break;
                 }

Editor/NetworkManagerEditor.cs

@@ -30,7 +30,9 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_ProtocolVersionProperty;
         private SerializedProperty m_NetworkTransportProperty;
         private SerializedProperty m_TickRateProperty;
-        private SerializedProperty m_SessionModeProperty;
+#if MULTIPLAYER_SERVICES_SDK_INSTALLED
+        private SerializedProperty m_NetworkTopologyProperty;
+#endif
         private SerializedProperty m_ClientConnectionBufferTimeoutProperty;
         private SerializedProperty m_ConnectionApprovalProperty;
         private SerializedProperty m_EnsureNetworkVariableLengthSafetyProperty;
@@ -43,6 +45,9 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_LoadSceneTimeOutProperty;
         private SerializedProperty m_PrefabsList;
 
+        private SerializedProperty m_NetworkProfileMetrics;
+        private SerializedProperty m_NetworkMessageMetrics;
+
         private NetworkManager m_NetworkManager;
         private bool m_Initialized;
 
@@ -97,7 +102,9 @@ namespace Unity.Netcode.Editor
             m_ProtocolVersionProperty = m_NetworkConfigProperty.FindPropertyRelative("ProtocolVersion");
             m_NetworkTransportProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTransport");
             m_TickRateProperty = m_NetworkConfigProperty.FindPropertyRelative("TickRate");
-            m_SessionModeProperty = m_NetworkConfigProperty.FindPropertyRelative("SessionMode");
+#if MULTIPLAYER_SERVICES_SDK_INSTALLED
+            m_NetworkTopologyProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTopology");
+#endif
             m_ClientConnectionBufferTimeoutProperty = m_NetworkConfigProperty.FindPropertyRelative("ClientConnectionBufferTimeout");
             m_ConnectionApprovalProperty = m_NetworkConfigProperty.FindPropertyRelative("ConnectionApproval");
             m_EnsureNetworkVariableLengthSafetyProperty = m_NetworkConfigProperty.FindPropertyRelative("EnsureNetworkVariableLengthSafety");
@@ -109,6 +116,11 @@ namespace Unity.Netcode.Editor
             m_SpawnTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("SpawnTimeout");
             m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
 
+            m_NetworkProfileMetrics = m_NetworkConfigProperty.FindPropertyRelative("NetworkProfileMetrics");
+#if MULTIPLAYER_TOOLS
+            m_NetworkMessageMetrics = m_NetworkConfigProperty.FindPropertyRelative("NetworkMessageMetrics");
+#endif
+
 
             m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
             m_PrefabsList = m_NetworkConfigProperty
@@ -130,7 +142,9 @@ namespace Unity.Netcode.Editor
             m_ProtocolVersionProperty = m_NetworkConfigProperty.FindPropertyRelative("ProtocolVersion");
             m_NetworkTransportProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTransport");
             m_TickRateProperty = m_NetworkConfigProperty.FindPropertyRelative("TickRate");
-            m_SessionModeProperty = m_NetworkConfigProperty.FindPropertyRelative("SessionMode");
+#if MULTIPLAYER_SERVICES_SDK_INSTALLED
+            m_NetworkTopologyProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkTopology");
+#endif
             m_ClientConnectionBufferTimeoutProperty = m_NetworkConfigProperty.FindPropertyRelative("ClientConnectionBufferTimeout");
             m_ConnectionApprovalProperty = m_NetworkConfigProperty.FindPropertyRelative("ConnectionApproval");
             m_EnsureNetworkVariableLengthSafetyProperty = m_NetworkConfigProperty.FindPropertyRelative("EnsureNetworkVariableLengthSafety");
@@ -143,6 +157,11 @@ namespace Unity.Netcode.Editor
             m_SpawnTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("SpawnTimeout");
             m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
 
+            m_NetworkProfileMetrics = m_NetworkConfigProperty.FindPropertyRelative("NetworkProfilingMetrics");
+#if MULTIPLAYER_TOOLS
+            m_NetworkMessageMetrics = m_NetworkConfigProperty.FindPropertyRelative("NetworkMessageMetrics");
+#endif
+
             m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
             m_PrefabsList = m_NetworkConfigProperty
                 .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
@@ -164,9 +183,12 @@ namespace Unity.Netcode.Editor
                 serializedObject.Update();
                 EditorGUILayout.PropertyField(m_RunInBackgroundProperty);
                 EditorGUILayout.PropertyField(m_LogLevelProperty);
-                EditorGUILayout.PropertyField(m_SessionModeProperty);
+
                 EditorGUILayout.Space();
                 EditorGUILayout.LabelField("Network Settings", EditorStyles.boldLabel);
+#if MULTIPLAYER_SERVICES_SDK_INSTALLED
+                EditorGUILayout.PropertyField(m_NetworkTopologyProperty);
+#endif
                 EditorGUILayout.PropertyField(m_ProtocolVersionProperty);
                 EditorGUILayout.PropertyField(m_NetworkTransportProperty);
                 if (m_NetworkTransportProperty.objectReferenceValue == null)
@@ -200,6 +222,11 @@ namespace Unity.Netcode.Editor
                 }
                 EditorGUILayout.PropertyField(m_RpcHashSizeProperty);
 
+                EditorGUILayout.PropertyField(m_NetworkProfileMetrics);
+#if MULTIPLAYER_TOOLS
+                EditorGUILayout.PropertyField(m_NetworkMessageMetrics);
+#endif
+
                 EditorGUILayout.Space();
                 EditorGUILayout.LabelField("Prefab Settings", EditorStyles.boldLabel);
                 EditorGUILayout.PropertyField(m_ForceSamePrefabsProperty);
@@ -283,20 +310,31 @@ namespace Unity.Netcode.Editor
                         GUI.enabled = false;
                     }
 
-                    if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
+                    if (m_NetworkManager.NetworkConfig.NetworkTopology == NetworkTopologyTypes.ClientServer)
                     {
-                        m_NetworkManager.StartHost();
+                        if (GUILayout.Button(new GUIContent("Start Host", "Starts a host instance" + buttonDisabledReasonSuffix)))
+                        {
+                            m_NetworkManager.StartHost();
+                        }
+
+                        if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
+                        {
+                            m_NetworkManager.StartServer();
+                        }
+
+                        if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
+                        {
+                            m_NetworkManager.StartClient();
+                        }
+                    }
+                    else
+                    {
+                        if (GUILayout.Button(new GUIContent("Start Client", "Starts a distributed authority client instance" + buttonDisabledReasonSuffix)))
+                        {
+                            m_NetworkManager.StartClient();
+                        }
                     }
 
-                    if (GUILayout.Button(new GUIContent("Start Server", "Starts a server instance" + buttonDisabledReasonSuffix)))
-                    {
-                        m_NetworkManager.StartServer();
-                    }
-
-                    if (GUILayout.Button(new GUIContent("Start Client", "Starts a client instance" + buttonDisabledReasonSuffix)))
-                    {
-                        m_NetworkManager.StartClient();
-                    }
 
                     if (!EditorApplication.isPlaying)
                     {

Editor/NetworkObjectEditor.cs

@@ -1,5 +1,7 @@
 using System.Collections.Generic;
+#if BYPASS_DEFAULT_ENUM_DRAWER && MULTIPLAYER_SERVICES_SDK_INSTALLED
 using System.Linq;
+#endif
 using UnityEditor;
 using UnityEngine;
 
@@ -144,7 +146,9 @@ namespace Unity.Netcode.Editor
         }
     }
 
-
+    // Keeping this here just in case, but it appears that in Unity 6 the visual bugs with
+    // enum flags is resolved
+#if BYPASS_DEFAULT_ENUM_DRAWER && MULTIPLAYER_SERVICES_SDK_INSTALLED
     [CustomPropertyDrawer(typeof(NetworkObject.OwnershipStatus))]
     public class NetworkObjectOwnership : PropertyDrawer
     {
@@ -188,4 +192,5 @@ namespace Unity.Netcode.Editor
             EditorGUI.EndProperty();
         }
     }
+#endif
 }

Editor/NetworkTransformEditor.cs

@@ -30,6 +30,7 @@ namespace Unity.Netcode.Editor
         private SerializedProperty m_UseQuaternionCompression;
         private SerializedProperty m_UseHalfFloatPrecision;
         private SerializedProperty m_SlerpPosition;
+        private SerializedProperty m_AuthorityMode;
 
         private static int s_ToggleOffset = 45;
         private static float s_MaxRowWidth = EditorGUIUtility.labelWidth + EditorGUIUtility.fieldWidth + 5;
@@ -38,7 +39,7 @@ namespace Unity.Netcode.Editor
         private static GUIContent s_ScaleLabel = EditorGUIUtility.TrTextContent("Scale");
 
         /// <inheritdoc/>
-        public void OnEnable()
+        public virtual void OnEnable()
         {
             m_UseUnreliableDeltas = serializedObject.FindProperty(nameof(NetworkTransform.UseUnreliableDeltas));
             m_SyncPositionXProperty = serializedObject.FindProperty(nameof(NetworkTransform.SyncPositionX));
@@ -59,12 +60,14 @@ namespace Unity.Netcode.Editor
             m_UseQuaternionCompression = serializedObject.FindProperty(nameof(NetworkTransform.UseQuaternionCompression));
             m_UseHalfFloatPrecision = serializedObject.FindProperty(nameof(NetworkTransform.UseHalfFloatPrecision));
             m_SlerpPosition = serializedObject.FindProperty(nameof(NetworkTransform.SlerpPosition));
+            m_AuthorityMode = serializedObject.FindProperty(nameof(NetworkTransform.AuthorityMode));
         }
 
         /// <inheritdoc/>
         public override void OnInspectorGUI()
         {
-            EditorGUILayout.LabelField("Syncing", EditorStyles.boldLabel);
+            var networkTransform = target as NetworkTransform;
+            EditorGUILayout.LabelField("Axis to Synchronize", EditorStyles.boldLabel);
             {
                 GUILayout.BeginHorizontal();
 
@@ -126,6 +129,11 @@ namespace Unity.Netcode.Editor
                 GUILayout.EndHorizontal();
             }
 
+            EditorGUILayout.Space();
+            EditorGUILayout.LabelField("Authority", EditorStyles.boldLabel);
+            {
+                EditorGUILayout.PropertyField(m_AuthorityMode);
+            }
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Thresholds", EditorStyles.boldLabel);
             EditorGUILayout.PropertyField(m_PositionThresholdProperty);
@@ -137,7 +145,10 @@ namespace Unity.Netcode.Editor
             EditorGUILayout.Space();
             EditorGUILayout.LabelField("Configurations", EditorStyles.boldLabel);
             EditorGUILayout.PropertyField(m_InLocalSpaceProperty);
-            EditorGUILayout.PropertyField(m_InterpolateProperty);
+            if (!networkTransform.HideInterpolateValue)
+            {
+                EditorGUILayout.PropertyField(m_InterpolateProperty);
+            }
             EditorGUILayout.PropertyField(m_SlerpPosition);
             EditorGUILayout.PropertyField(m_UseQuaternionSynchronization);
             if (m_UseQuaternionSynchronization.boolValue)

Editor/com.unity.netcode.editor.asmdef

@@ -53,6 +53,11 @@
             "name": "com.unity.transport",
             "expression": "2.0",
             "define": "UTP_TRANSPORT_2_0_ABOVE"
+        },
+        {
+            "name": "com.unity.services.multiplayer",
+            "expression": "0.2.0",
+            "define": "MULTIPLAYER_SERVICES_SDK_INSTALLED"
         }
     ],
     "noEngineReferences": false

Runtime/Components.meta

@@ -1,5 +1,5 @@
 fileFormatVersion: 2
-guid: 8b267eb841a574dc083ac248a95d4443
+guid: 2e42215d00468b549bbc69ebf8a74a1e
 folderAsset: yes
 DefaultImporter:
   externalObjects: {}

Runtime/Components/AnticipatedNetworkTransform.cs

@@ -0,0 +1,497 @@
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode.Components
+{
+
+#pragma warning disable IDE0001
+    /// <summary>
+    /// A subclass of <see cref="NetworkTransform"/> that supports basic client anticipation - the client
+    /// can set a value on the belief that the server will update it to reflect the same value in a future update
+    /// (i.e., as the result of an RPC call). This value can then be adjusted as new updates from the server come in,
+    /// in three basic modes:
+    ///
+    /// <list type="bullet">
+    ///
+    /// <item><b>Snap:</b> In this mode (with <see cref="StaleDataHandling"/> set to
+    /// <see cref="StaleDataHandling.Ignore"/> and no <see cref="NetworkBehaviour.OnReanticipate"/> callback),
+    /// the moment a more up-to-date value is received from the authority, it will simply replace the anticipated value,
+    /// resulting in a "snap" to the new value if it is different from the anticipated value.</item>
+    ///
+    /// <item><b>Smooth:</b> In this mode (with <see cref="StaleDataHandling"/> set to
+    /// <see cref="Netcode.StaleDataHandling.Ignore"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> callback that calls
+    /// <see cref="Smooth"/> from the anticipated value to the authority value with an appropriate
+    /// <see cref="Mathf.Lerp"/>-style smooth function), when a more up-to-date value is received from the authority,
+    /// it will interpolate over time from an incorrect anticipated value to the correct authoritative value.</item>
+    ///
+    /// <item><b>Constant Reanticipation:</b> In this mode (with <see cref="StaleDataHandling"/> set to
+    /// <see cref="Netcode.StaleDataHandling.Reanticipate"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> that calculates a
+    /// new anticipated value based on the current authoritative value), when a more up-to-date value is received from
+    /// the authority, user code calculates a new anticipated value, possibly calling <see cref="Smooth"/> to interpolate
+    /// between the previous anticipation and the new anticipation. This is useful for values that change frequently and
+    /// need to constantly be re-evaluated, as opposed to values that change only in response to user action and simply
+    /// need a one-time anticipation when the user performs that action.</item>
+    ///
+    /// </list>
+    ///
+    /// Note that these three modes may be combined. For example, if an <see cref="NetworkBehaviour.OnReanticipate"/> callback
+    /// does not call either <see cref="Smooth"/> or one of the Anticipate methods, the result will be a snap to the
+    /// authoritative value, enabling for a callback that may conditionally call <see cref="Smooth"/> when the
+    /// difference between the anticipated and authoritative values is within some threshold, but fall back to
+    /// snap behavior if the difference is too large.
+    /// </summary>
+#pragma warning restore IDE0001
+    [DisallowMultipleComponent]
+    [AddComponentMenu("Netcode/Anticipated Network Transform")]
+    public class AnticipatedNetworkTransform : NetworkTransform
+    {
+
+#if UNITY_EDITOR
+        internal override bool HideInterpolateValue => true;
+#endif
+
+        public struct TransformState
+        {
+            public Vector3 Position;
+            public Quaternion Rotation;
+            public Vector3 Scale;
+        }
+
+        private TransformState m_AuthoritativeTransform = new TransformState();
+        private TransformState m_AnticipatedTransform = new TransformState();
+        private TransformState m_PreviousAnticipatedTransform = new TransformState();
+        private ulong m_LastAnticipaionCounter;
+        private ulong m_LastAuthorityUpdateCounter;
+
+        private TransformState m_SmoothFrom;
+        private TransformState m_SmoothTo;
+        private float m_SmoothDuration;
+        private float m_CurrentSmoothTime;
+
+        private bool m_OutstandingAuthorityChange = false;
+
+#if UNITY_EDITOR
+        private void Reset()
+        {
+            // Anticipation + smoothing is a form of interpolation, and adding NetworkTransform's buffered interpolation
+            // makes the anticipation get weird, so we default it to false.
+            Interpolate = false;
+        }
+#endif
+
+#pragma warning disable IDE0001
+        /// <summary>
+        /// Defines what the behavior should be if we receive a value from the server with an earlier associated
+        /// time value than the anticipation time value.
+        /// <br/><br/>
+        /// If this is <see cref="Netcode.StaleDataHandling.Ignore"/>, the stale data will be ignored and the authoritative
+        /// value will not replace the anticipated value until the anticipation time is reached. <see cref="OnAuthoritativeValueChanged"/>
+        /// and <see cref="OnReanticipate"/> will also not be invoked for this stale data.
+        /// <br/><br/>
+        /// If this is <see cref="Netcode.StaleDataHandling.Reanticipate"/>, the stale data will replace the anticipated data and
+        /// <see cref="OnAuthoritativeValueChanged"/> and <see cref="OnReanticipate"/> will be invoked.
+        /// In this case, the authoritativeTime value passed to <see cref="OnReanticipate"/> will be lower than
+        /// the anticipationTime value, and that callback can be used to calculate a new anticipated value.
+        /// </summary>
+#pragma warning restore IDE0001
+        public StaleDataHandling StaleDataHandling = StaleDataHandling.Reanticipate;
+
+        /// <summary>
+        /// Contains the current state of this transform on the server side.
+        /// Note that, on the server side, this gets updated at the end of the frame, and will not immediately reflect
+        /// changes to the transform.
+        /// </summary>
+        public TransformState AuthoritativeState => m_AuthoritativeTransform;
+
+        /// <summary>
+        /// Contains the current anticipated state, which will match the values of this object's
+        /// actual <see cref="MonoBehaviour.transform"/>. When a server
+        /// update arrives, this value will be overwritten by the new
+        /// server value (unless stale data handling is set to "Ignore"
+        /// and the update is determined to be stale). This value will
+        /// be duplicated in <see cref="PreviousAnticipatedState"/>, which
+        /// will NOT be overwritten in server updates.
+        /// </summary>
+        public TransformState AnticipatedState => m_AnticipatedTransform;
+
+        /// <summary>
+        /// Indicates whether this transform currently needs
+        /// reanticipation. If this is true, the anticipated value
+        /// has been overwritten by the authoritative value from the
+        /// server; the previous anticipated value is stored in <see cref="PreviousAnticipatedState"/>
+        /// </summary>
+        public bool ShouldReanticipate
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Holds the most recent anticipated state, whatever was
+        /// most recently set using the Anticipate methods. Unlike
+        /// <see cref="AnticipatedState"/>, this does not get overwritten
+        /// when a server update arrives.
+        /// </summary>
+        public TransformState PreviousAnticipatedState => m_PreviousAnticipatedTransform;
+
+        /// <summary>
+        /// Anticipate that, at the end of one round trip to the server, this transform will be in the given
+        /// <see cref="newPosition"/>
+        /// </summary>
+        /// <param name="newPosition"></param>
+        public void AnticipateMove(Vector3 newPosition)
+        {
+            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
+            {
+                return;
+            }
+            transform.position = newPosition;
+            m_AnticipatedTransform.Position = newPosition;
+            if (CanCommitToTransform)
+            {
+                m_AuthoritativeTransform.Position = newPosition;
+            }
+
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+        }
+
+        /// <summary>
+        /// Anticipate that, at the end of one round trip to the server, this transform will have the given
+        /// <see cref="newRotation"/>
+        /// </summary>
+        /// <param name="newRotation"></param>
+        public void AnticipateRotate(Quaternion newRotation)
+        {
+            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
+            {
+                return;
+            }
+            transform.rotation = newRotation;
+            m_AnticipatedTransform.Rotation = newRotation;
+            if (CanCommitToTransform)
+            {
+                m_AuthoritativeTransform.Rotation = newRotation;
+            }
+
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+        }
+
+        /// <summary>
+        /// Anticipate that, at the end of one round trip to the server, this transform will have the given
+        /// <see cref="newScale"/>
+        /// </summary>
+        /// <param name="newScale"></param>
+        public void AnticipateScale(Vector3 newScale)
+        {
+            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
+            {
+                return;
+            }
+            transform.localScale = newScale;
+            m_AnticipatedTransform.Scale = newScale;
+            if (CanCommitToTransform)
+            {
+                m_AuthoritativeTransform.Scale = newScale;
+            }
+
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            m_LastAnticipaionCounter = NetworkManager.AnticipationSystem.AnticipationCounter;
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+        }
+
+        /// <summary>
+        /// Anticipate that, at the end of one round trip to the server, the transform will have the given
+        /// <see cref="newState"/>
+        /// </summary>
+        /// <param name="newState"></param>
+        public void AnticipateState(TransformState newState)
+        {
+            if (NetworkManager.ShutdownInProgress || !NetworkManager.IsListening)
+            {
+                return;
+            }
+            var transform_ = transform;
+            transform_.position = newState.Position;
+            transform_.rotation = newState.Rotation;
+            transform_.localScale = newState.Scale;
+            m_AnticipatedTransform = newState;
+            if (CanCommitToTransform)
+            {
+                m_AuthoritativeTransform = newState;
+            }
+
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+        }
+
+        public override void OnUpdate()
+        {
+            // If not spawned or this instance has authority, exit early
+            if (!IsSpawned)
+            {
+                return;
+            }
+            // Do not call the base class implementation...
+            // AnticipatedNetworkTransform applies its authoritative state immediately rather than waiting for update
+            // This is because AnticipatedNetworkTransforms may need to reference each other in reanticipating
+            // and we will want all reanticipation done before anything else wants to reference the transform in
+            // OnUpdate()
+            //base.Update();
+
+            if (m_CurrentSmoothTime < m_SmoothDuration)
+            {
+                m_CurrentSmoothTime += NetworkManager.RealTimeProvider.DeltaTime;
+                var transform_ = transform;
+                var pct = math.min(m_CurrentSmoothTime / m_SmoothDuration, 1f);
+
+                m_AnticipatedTransform = new TransformState
+                {
+                    Position = Vector3.Lerp(m_SmoothFrom.Position, m_SmoothTo.Position, pct),
+                    Rotation = Quaternion.Slerp(m_SmoothFrom.Rotation, m_SmoothTo.Rotation, pct),
+                    Scale = Vector3.Lerp(m_SmoothFrom.Scale, m_SmoothTo.Scale, pct)
+                };
+                m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+                if (!CanCommitToTransform)
+                {
+                    transform_.position = m_AnticipatedTransform.Position;
+                    transform_.localScale = m_AnticipatedTransform.Scale;
+                    transform_.rotation = m_AnticipatedTransform.Rotation;
+                }
+            }
+        }
+
+        internal class AnticipatedObject : IAnticipationEventReceiver, IAnticipatedObject
+        {
+            public AnticipatedNetworkTransform Transform;
+
+
+            public void SetupForRender()
+            {
+                if (Transform.CanCommitToTransform)
+                {
+                    var transform_ = Transform.transform;
+                    Transform.m_AuthoritativeTransform = new TransformState
+                    {
+                        Position = transform_.position,
+                        Rotation = transform_.rotation,
+                        Scale = transform_.localScale
+                    };
+                    if (Transform.m_CurrentSmoothTime >= Transform.m_SmoothDuration)
+                    {
+                        // If we've had a call to Smooth() we'll continue interpolating.
+                        // Otherwise we'll go ahead and make the visual and actual locations
+                        // match.
+                        Transform.m_AnticipatedTransform = Transform.m_AuthoritativeTransform;
+                    }
+
+                    transform_.position = Transform.m_AnticipatedTransform.Position;
+                    transform_.rotation = Transform.m_AnticipatedTransform.Rotation;
+                    transform_.localScale = Transform.m_AnticipatedTransform.Scale;
+                }
+            }
+
+            public void SetupForUpdate()
+            {
+                if (Transform.CanCommitToTransform)
+                {
+                    var transform_ = Transform.transform;
+                    transform_.position = Transform.m_AuthoritativeTransform.Position;
+                    transform_.rotation = Transform.m_AuthoritativeTransform.Rotation;
+                    transform_.localScale = Transform.m_AuthoritativeTransform.Scale;
+                }
+            }
+
+            public void Update()
+            {
+                // No need to do this, it's handled by NetworkTransform.OnUpdate
+            }
+
+            public void ResetAnticipation()
+            {
+                Transform.ShouldReanticipate = false;
+            }
+
+            public NetworkObject OwnerObject => Transform.NetworkObject;
+        }
+
+        private AnticipatedObject m_AnticipatedObject = null;
+
+        private void ResetAnticipatedState()
+        {
+            var transform_ = transform;
+            m_AuthoritativeTransform = new TransformState
+            {
+                Position = transform_.position,
+                Rotation = transform_.rotation,
+                Scale = transform_.localScale
+            };
+            m_AnticipatedTransform = m_AuthoritativeTransform;
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+        }
+
+        protected override void OnSynchronize<T>(ref BufferSerializer<T> serializer)
+        {
+            base.OnSynchronize(ref serializer);
+            if (!CanCommitToTransform)
+            {
+                m_OutstandingAuthorityChange = true;
+                ApplyAuthoritativeState();
+                ResetAnticipatedState();
+            }
+        }
+
+        public override void OnNetworkSpawn()
+        {
+            base.OnNetworkSpawn();
+            m_OutstandingAuthorityChange = true;
+            ApplyAuthoritativeState();
+            ResetAnticipatedState();
+
+            m_AnticipatedObject = new AnticipatedObject { Transform = this };
+            NetworkManager.AnticipationSystem.RegisterForAnticipationEvents(m_AnticipatedObject);
+            NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
+        }
+
+        public override void OnNetworkDespawn()
+        {
+            if (m_AnticipatedObject != null)
+            {
+                NetworkManager.AnticipationSystem.DeregisterForAnticipationEvents(m_AnticipatedObject);
+                NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
+                NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
+                m_AnticipatedObject = null;
+            }
+            ResetAnticipatedState();
+
+            base.OnNetworkDespawn();
+        }
+
+        public override void OnDestroy()
+        {
+            if (m_AnticipatedObject != null)
+            {
+                NetworkManager.AnticipationSystem.DeregisterForAnticipationEvents(m_AnticipatedObject);
+                NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
+                NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
+                m_AnticipatedObject = null;
+            }
+
+            base.OnDestroy();
+        }
+
+        /// <summary>
+        /// Interpolate between the transform represented by <see cref="from"/> to the transform represented by
+        /// <see cref="to"/> over <see cref="durationSeconds"/> of real time. The duration uses
+        /// <see cref="Time.deltaTime"/>, so it is affected by <see cref="Time.timeScale"/>.
+        /// </summary>
+        /// <param name="from"></param>
+        /// <param name="to"></param>
+        /// <param name="durationSeconds"></param>
+        public void Smooth(TransformState from, TransformState to, float durationSeconds)
+        {
+            var transform_ = transform;
+            if (durationSeconds <= 0)
+            {
+                m_AnticipatedTransform = to;
+                m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+                transform_.position = to.Position;
+                transform_.rotation = to.Rotation;
+                transform_.localScale = to.Scale;
+                m_SmoothDuration = 0;
+                m_CurrentSmoothTime = 0;
+                return;
+            }
+            m_AnticipatedTransform = from;
+            m_PreviousAnticipatedTransform = m_AnticipatedTransform;
+
+            if (!CanCommitToTransform)
+            {
+                transform_.position = from.Position;
+                transform_.rotation = from.Rotation;
+                transform_.localScale = from.Scale;
+            }
+
+            m_SmoothFrom = from;
+            m_SmoothTo = to;
+            m_SmoothDuration = durationSeconds;
+            m_CurrentSmoothTime = 0;
+        }
+
+        protected override void OnBeforeUpdateTransformState()
+        {
+            // this is called when new data comes from the server
+            m_LastAuthorityUpdateCounter = NetworkManager.AnticipationSystem.LastAnticipationAck;
+            m_OutstandingAuthorityChange = true;
+        }
+
+        protected override void OnNetworkTransformStateUpdated(ref NetworkTransformState oldState, ref NetworkTransformState newState)
+        {
+            base.OnNetworkTransformStateUpdated(ref oldState, ref newState);
+            ApplyAuthoritativeState();
+        }
+
+        protected override void OnTransformUpdated()
+        {
+            if (CanCommitToTransform || m_AnticipatedObject == null)
+            {
+                return;
+            }
+            // this is called pretty much every frame and will change the transform
+            // If we've overridden the transform with an anticipated state, we need to be able to change it back
+            // to the anticipated state (while updating the authority state accordingly) or else
+            // mark this transform for reanticipation
+            var transform_ = transform;
+
+            var previousAnticipatedTransform = m_AnticipatedTransform;
+
+            // Update authority state to catch any possible interpolation data
+            m_AuthoritativeTransform.Position = transform_.position;
+            m_AuthoritativeTransform.Rotation = transform_.rotation;
+            m_AuthoritativeTransform.Scale = transform_.localScale;
+
+            if (!m_OutstandingAuthorityChange)
+            {
+                // Keep the anticipated value unchanged, we have no updates from the server at all.
+                transform_.position = previousAnticipatedTransform.Position;
+                transform_.localScale = previousAnticipatedTransform.Scale;
+                transform_.rotation = previousAnticipatedTransform.Rotation;
+                return;
+            }
+
+            if (StaleDataHandling == StaleDataHandling.Ignore && m_LastAnticipaionCounter > m_LastAuthorityUpdateCounter)
+            {
+                // Keep the anticipated value unchanged because it is more recent than the authoritative one.
+                transform_.position = previousAnticipatedTransform.Position;
+                transform_.localScale = previousAnticipatedTransform.Scale;
+                transform_.rotation = previousAnticipatedTransform.Rotation;
+                return;
+            }
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+            m_OutstandingAuthorityChange = false;
+            m_AnticipatedTransform = m_AuthoritativeTransform;
+
+            ShouldReanticipate = true;
+            NetworkManager.AnticipationSystem.ObjectsToReanticipate.Add(m_AnticipatedObject);
+        }
+    }
+}

Runtime/Components/AnticipatedNetworkTransform.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 5abfce83aadd948498d4990c645a017b

Runtime/Components/Interpolator/BufferedLinearInterpolator.cs

@@ -195,7 +195,9 @@ namespace Unity.Netcode
                 double range = m_EndTimeConsumed - m_StartTimeConsumed;
                 if (range > k_SmallValue)
                 {
-                    t = (float)((renderTime - m_StartTimeConsumed) / range);
+                    var rangeFactor = 1.0f / (float)range;
+
+                    t = ((float)renderTime - (float)m_StartTimeConsumed) * rangeFactor;
 
                     if (t < 0.0f)
                     {

Runtime/Components/NetworkAnimator.cs

@@ -186,7 +186,6 @@ namespace Unity.Netcode.Components
     /// NetworkAnimator enables remote synchronization of <see cref="UnityEngine.Animator"/> state for on network objects.
     /// </summary>
     [AddComponentMenu("Netcode/Network Animator")]
-    [RequireComponent(typeof(Animator))]
     public class NetworkAnimator : NetworkBehaviour, ISerializationCallbackReceiver
     {
         [Serializable]

Runtime/Components/NetworkDeltaPosition.cs

@@ -32,9 +32,13 @@ namespace Unity.Netcode.Components
         /// </summary>
         public void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
         {
-            HalfVector3.NetworkSerialize(serializer);
+            if (!SynchronizeBase)
-            if (SynchronizeBase)
             {
+                HalfVector3.NetworkSerialize(serializer);
+            }
+            else
+            {
+                serializer.SerializeValue(ref DeltaPosition);
                 serializer.SerializeValue(ref CurrentBasePosition);
             }
         }

Runtime/Components/NetworkRigidBodyBase.cs

@@ -23,6 +23,7 @@ namespace Unity.Netcode.Components
         /// extrapolation and <see cref="NetworkTransform.Interpolate"/> is enabled, then non-authoritative instances will automatically be adjusted to use Rigidbody
         /// interpolation while the authoritative instance will still use extrapolation.
         /// </remarks>
+        [Tooltip("When enabled and a NetworkTransform component is attached, the NetworkTransform will use the rigid body for motion and detecting changes in state.")]
         public bool UseRigidBodyForMotion;
 
         /// <summary>
@@ -43,7 +44,10 @@ namespace Unity.Netcode.Components
         private bool m_IsAuthority;
         private Rigidbody m_Rigidbody;
         private Rigidbody2D m_Rigidbody2D;
-        private NetworkTransform m_NetworkTransform;
+        internal NetworkTransform NetworkTransform;
+        private float m_TickFrequency;
+        private float m_TickRate;
+
         private enum InterpolationTypes
         {
             None,
@@ -85,7 +89,7 @@ namespace Unity.Netcode.Components
             RigidbodyType = rigidbodyType;
             m_Rigidbody2D = rigidbody2D;
             m_Rigidbody = rigidbody;
-            m_NetworkTransform = networkTransform;
+            NetworkTransform = networkTransform;
 
             if (m_IsRigidbody2D && m_Rigidbody2D == null)
             {
@@ -99,14 +103,14 @@ namespace Unity.Netcode.Components
 
             SetOriginalInterpolation();
 
-            if (m_NetworkTransform == null)
+            if (NetworkTransform == null)
             {
-                m_NetworkTransform = GetComponent<NetworkTransform>();
+                NetworkTransform = GetComponent<NetworkTransform>();
             }
 
-            if (m_NetworkTransform != null)
+            if (NetworkTransform != null)
             {
-                m_NetworkTransform.RegisterRigidbody(this);
+                NetworkTransform.RegisterRigidbody(this);
             }
             else
             {
@@ -119,6 +123,129 @@ namespace Unity.Netcode.Components
             }
         }
 
+        internal Vector3 GetAdjustedPositionThreshold()
+        {
+            // Since the threshold is a measurement of unity world space units per tick, we will allow for the maximum threshold
+            // to be no greater than the threshold measured in unity world space units per second
+            var thresholdMax = NetworkTransform.PositionThreshold * m_TickRate;
+            // Get the velocity in unity world space units per tick
+            var perTickVelocity = GetLinearVelocity() * m_TickFrequency;
+            // Since a rigid body can have "micro-motion" when allowed to come to rest (based on friction etc), we will allow for
+            // no less than 1/10th the threshold value.
+            var minThreshold = NetworkTransform.PositionThreshold * 0.1f;
+
+            // Finally, we adjust the threshold based on the body's current velocity
+            perTickVelocity.x = Mathf.Clamp(Mathf.Abs(perTickVelocity.x), minThreshold, thresholdMax);
+            perTickVelocity.y = Mathf.Clamp(Mathf.Abs(perTickVelocity.y), minThreshold, thresholdMax);
+            // 2D Rigidbody only moves on x & y axis
+            if (!m_IsRigidbody2D)
+            {
+                perTickVelocity.z = Mathf.Clamp(Mathf.Abs(perTickVelocity.z), minThreshold, thresholdMax);
+            }
+
+            return perTickVelocity;
+        }
+
+        internal Vector3 GetAdjustedRotationThreshold()
+        {
+            // Since the rotation threshold is a measurement pf degrees per tick, we get the maximum threshold
+            // by calculating the threshold in degrees per second.
+            var thresholdMax = NetworkTransform.RotAngleThreshold * m_TickRate;
+            // Angular velocity is expressed in radians per second where as the rotation being checked is in degrees.
+            // Convert the angular velocity to degrees per second and then convert that to degrees per tick.
+            var rotationPerTick = (GetAngularVelocity() * Mathf.Rad2Deg) * m_TickFrequency;
+            var minThreshold = NetworkTransform.RotAngleThreshold * m_TickFrequency;
+
+            // 2D Rigidbody only rotates around Z axis
+            if (!m_IsRigidbody2D)
+            {
+                rotationPerTick.x = Mathf.Clamp(Mathf.Abs(rotationPerTick.x), minThreshold, thresholdMax);
+                rotationPerTick.y = Mathf.Clamp(Mathf.Abs(rotationPerTick.y), minThreshold, thresholdMax);
+            }
+            rotationPerTick.z = Mathf.Clamp(Mathf.Abs(rotationPerTick.z), minThreshold, thresholdMax);
+
+            return rotationPerTick;
+        }
+
+        /// <summary>
+        /// Sets the linear velocity of the Rigidbody.
+        /// </summary>
+        /// <remarks>
+        /// For <see cref="Rigidbody2D"/>, only the x and y components of the <see cref="Vector3"/> are applied.
+        /// </remarks>        
+        public void SetLinearVelocity(Vector3 linearVelocity)
+        {
+            if (m_IsRigidbody2D)
+            {
+                m_Rigidbody2D.velocity = linearVelocity;
+            }
+            else
+            {
+                m_Rigidbody.linearVelocity = linearVelocity;
+            }
+        }
+
+        /// <summary>
+        /// Gets the linear velocity of the Rigidbody.
+        /// </summary>
+        /// <remarks>
+        /// For <see cref="Rigidbody2D"/>, the <see cref="Vector3"/> velocity returned is only applied to the x and y components.
+        /// </remarks>
+        /// <returns><see cref="Vector3"/> as the linear velocity</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetLinearVelocity()
+        {
+            if (m_IsRigidbody2D)
+            {
+                return m_Rigidbody2D.velocity;
+            }
+            else
+            {
+                return m_Rigidbody.linearVelocity;
+            }
+        }
+
+        /// <summary>
+        /// Sets the angular velocity for the Rigidbody.
+        /// </summary>
+        /// <remarks>
+        /// For <see cref="Rigidbody2D"/>, the z component of <param name="angularVelocity"/> is only used to set the angular velocity.
+        /// A quick way to pass in a 2D angular velocity component is: <see cref="Vector3.forward"/> * angularVelocity (where angularVelocity is a float)
+        /// </remarks>
+        /// <param name="angularVelocity">the angular velocity to apply to the body</param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetAngularVelocity(Vector3 angularVelocity)
+        {
+            if (m_IsRigidbody2D)
+            {
+                m_Rigidbody2D.angularVelocity = angularVelocity.z;
+            }
+            else
+            {
+                m_Rigidbody.angularVelocity = angularVelocity;
+            }
+        }
+
+        /// <summary>
+        /// Gets the angular velocity for the Rigidbody.
+        /// </summary>
+        /// <remarks>
+        /// For <see cref="Rigidbody2D"/>, the z component of the <see cref="Vector3"/> returned is the angular velocity of the object.
+        /// </remarks>
+        /// <returns>angular velocity as a <see cref="Vector3"/></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public Vector3 GetAngularVelocity()
+        {
+            if (m_IsRigidbody2D)
+            {
+                return Vector3.forward * m_Rigidbody2D.velocity;
+            }
+            else
+            {
+                return m_Rigidbody.angularVelocity;
+            }
+        }
+
         /// <summary>
         /// Gets the position of the Rigidbody
         /// </summary>
@@ -209,6 +336,9 @@ namespace Unity.Netcode.Components
             }
         }
 
+        // Used for Rigidbody only (see info on normalized below)
+        private Vector4 m_QuaternionCheck = Vector4.zero;
+
         /// <summary>
         /// Rotatates the Rigidbody towards a specified rotation
         /// </summary>
@@ -218,10 +348,25 @@ namespace Unity.Netcode.Components
         {
             if (m_IsRigidbody2D)
             {
-                m_Rigidbody2D.MoveRotation(rotation);
+                var quaternion = Quaternion.identity;
+                var angles = quaternion.eulerAngles;
+                angles.z = m_Rigidbody2D.rotation;
+                quaternion.eulerAngles = angles;
+                m_Rigidbody2D.MoveRotation(quaternion);
             }
             else
             {
+                // Evidently we need to check to make sure the quaternion is a perfect
+                // magnitude of 1.0f when applying the rotation to a rigid body.
+                m_QuaternionCheck.x = rotation.x;
+                m_QuaternionCheck.y = rotation.y;
+                m_QuaternionCheck.z = rotation.z;
+                m_QuaternionCheck.w = rotation.w;
+                // If the magnitude is greater than 1.0f (even by a very small fractional value), then normalize the quaternion
+                if (m_QuaternionCheck.magnitude != 1.0f)
+                {
+                    rotation.Normalize();
+                }
                 m_Rigidbody.MoveRotation(rotation);
             }
         }
@@ -381,7 +526,7 @@ namespace Unity.Netcode.Components
             if (UseRigidBodyForMotion)
             {
                 // Only if the NetworkTransform is set to interpolate do we need to check for extrapolation
-                if (m_NetworkTransform.Interpolate && m_OriginalInterpolation == InterpolationTypes.Extrapolate)
+                if (NetworkTransform.Interpolate && m_OriginalInterpolation == InterpolationTypes.Extrapolate)
                 {
                     if (IsKinematic())
                     {
@@ -402,7 +547,7 @@ namespace Unity.Netcode.Components
             }
             else
             {
-                SetInterpolation(m_IsAuthority ? m_OriginalInterpolation : (m_NetworkTransform.Interpolate ? InterpolationTypes.None : m_OriginalInterpolation));
+                SetInterpolation(m_IsAuthority ? m_OriginalInterpolation : (NetworkTransform.Interpolate ? InterpolationTypes.None : m_OriginalInterpolation));
             }
         }
 
@@ -477,7 +622,7 @@ namespace Unity.Netcode.Components
             }
             else
             {
-                if (m_NetworkTransform.IsServerAuthoritative())
+                if (NetworkTransform.IsServerAuthoritative())
                 {
                     m_IsAuthority = NetworkManager.IsServer;
                 }
@@ -496,12 +641,20 @@ namespace Unity.Netcode.Components
         /// <inheritdoc />
         public override void OnNetworkSpawn()
         {
+            m_TickFrequency = 1.0f / NetworkManager.NetworkConfig.TickRate;
+            m_TickRate = NetworkManager.NetworkConfig.TickRate;
             UpdateOwnershipAuthority();
         }
 
         /// <inheritdoc />
         public override void OnNetworkDespawn()
         {
+            if (UseRigidBodyForMotion && HasAuthority)
+            {
+                DetachFromFixedJoint();
+                NetworkRigidbodyConnections.Clear();
+            }
+
             // If we are automatically handling the kinematic state...
             if (AutoUpdateKinematicState || AutoSetKinematicOnDespawn)
             {
@@ -513,21 +666,197 @@ namespace Unity.Netcode.Components
             SetInterpolation(m_OriginalInterpolation);
         }
 
+        // TODO: Possibly provide a NetworkJoint that allows for more options than fixed.
+        // Rigidbodies do not have the concept of "local space", and as such using a fixed joint will hold the object
+        // in place relative to the parent so jitter/stutter does not occur.
+        // Alternately, users can affix the fixed joint to a child GameObject (without a rigid body) of the parent NetworkObject
+        // and then add a NetworkTransform to that in order to get the parented child NetworkObject to move around in "local space"
+        public FixedJoint FixedJoint { get; private set; }
+        public FixedJoint2D FixedJoint2D { get; private set; }
+
+        internal System.Collections.Generic.List<NetworkRigidbodyBase> NetworkRigidbodyConnections = new System.Collections.Generic.List<NetworkRigidbodyBase>();
+        internal NetworkRigidbodyBase ParentBody;
+
+        private bool m_FixedJoint2DUsingGravity;
+        private bool m_OriginalGravitySetting;
+        private float m_OriginalGravityScale;
+
         /// <summary>
-        /// When <see cref="UseRigidBodyForMotion"/> is enabled, the <see cref="NetworkTransform"/> will update Kinematic instances using
+        /// When using a custom <see cref="NetworkRigidbodyBase"/>, this virtual method is invoked when the
-        /// the Rigidbody's move methods allowing Rigidbody interpolation settings to be taken into consideration by the physics simulation.
+        /// <see cref="FixedJoint"/> is created in the event any additional adjustments are needed.
+        /// </summary>
+        protected virtual void OnFixedJointCreated()
+        {
+
+        }
+
+        /// <summary>
+        /// When using a custom <see cref="NetworkRigidbodyBase"/>, this virtual method is invoked when the
+        /// <see cref="FixedJoint2D"/> is created in the event any additional adjustments are needed.
+        /// </summary>
+        protected virtual void OnFixedJoint2DCreated()
+        {
+
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void ApplyFixedJoint2D(NetworkRigidbodyBase bodyToConnect, Vector3 position, float connectedMassScale = 0.0f, float massScale = 1.0f, bool useGravity = false, bool zeroVelocity = true)
+        {
+            transform.position = position;
+            m_Rigidbody2D.position = position;
+            m_OriginalGravitySetting = bodyToConnect.m_Rigidbody.useGravity;
+            m_FixedJoint2DUsingGravity = useGravity;
+
+            if (!useGravity)
+            {
+                m_OriginalGravityScale = m_Rigidbody2D.gravityScale;
+                m_Rigidbody2D.gravityScale = 0.0f;
+            }
+
+            if (zeroVelocity)
+            {
+                m_Rigidbody2D.velocity = Vector2.zero;
+                m_Rigidbody2D.angularVelocity = 0.0f;
+            }
+
+            FixedJoint2D = gameObject.AddComponent<FixedJoint2D>();
+            FixedJoint2D.connectedBody = bodyToConnect.m_Rigidbody2D;
+            OnFixedJoint2DCreated();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void ApplyFixedJoint(NetworkRigidbodyBase bodyToConnectTo, Vector3 position, float connectedMassScale = 0.0f, float massScale = 1.0f, bool useGravity = false, bool zeroVelocity = true)
+        {
+            transform.position = position;
+            m_Rigidbody.position = position;
+            if (zeroVelocity)
+            {
+                m_Rigidbody.linearVelocity = Vector3.zero;
+                m_Rigidbody.angularVelocity = Vector3.zero;
+            }
+            m_OriginalGravitySetting = m_Rigidbody.useGravity;
+            m_Rigidbody.useGravity = useGravity;
+            FixedJoint = gameObject.AddComponent<FixedJoint>();
+            FixedJoint.connectedBody = bodyToConnectTo.m_Rigidbody;
+            FixedJoint.connectedMassScale = connectedMassScale;
+            FixedJoint.massScale = massScale;
+            OnFixedJointCreated();
+        }
+
+
+        /// <summary>
+        /// Authority Only:
+        /// When invoked and not already attached to a fixed joint, this will connect two rigid bodies with <see cref="UseRigidBodyForMotion"/> enabled.
+        /// Invoke this method on the rigid body you wish to attach to another (i.e. weapon to player, sticky bomb to player/object, etc).
+        /// <seealso cref="FixedJoint"/>
+        /// <seealso cref="FixedJoint2D"/>
         /// </summary>
         /// <remarks>
-        /// This will update the associated <see cref="NetworkTransform"/> during FixedUpdate which also avoids the added expense of adding
+        /// Parenting relative:
-        /// a FixedUpdate to all <see cref="NetworkTransform"/> instances where some might not be using a Rigidbody.
+        /// - This instance can be viewed as the child.
+        /// - The <param name="objectToConnectTo"/> can be viewed as the parent.
+        /// <br/>
+        /// This is the recommended way, as opposed to parenting, to attached/detatch two rigid bodies to one another when <see cref="UseRigidBodyForMotion"/> is enabled.
+        /// For more details on using <see cref="UnityEngine.FixedJoint"/> and <see cref="UnityEngine.FixedJoint2D"/>.
+        /// <br/>
+        /// This provides a simple joint solution between two rigid bodies and serves as an example. You can add different joint types by creating a customized/derived
+        /// version of <see cref="NetworkRigidbodyBase"/>.
         /// </remarks>
-        private void FixedUpdate()
+        /// <param name="objectToConnectTo">The target object to attach to.</param>
+        /// <param name="positionOfConnection">The position of the connection (i.e. where you want the object to be affixed).</param>
+        /// <param name="connectedMassScale">The target object's mass scale relative to this object being attached.</param>
+        /// <param name="massScale">This object's mass scale relative to the target object's.</param>
+        /// <param name="useGravity">Determines if this object will have gravity applied to it along with the object you are connecting this one to (the default is to not use gravity for this object)</param>
+        /// <param name="zeroVelocity">When true (the default), both linear and angular velocities of this object are set to zero.</param>
+        /// <param name="teleportObject">When true (the default), this object will teleport itself to the position of connection.</param>
+        /// <returns>true (success) false (failed)</returns>
+        public bool AttachToFixedJoint(NetworkRigidbodyBase objectToConnectTo, Vector3 positionOfConnection, float connectedMassScale = 0.0f, float massScale = 1.0f, bool useGravity = false, bool zeroVelocity = true, bool teleportObject = true)
         {
-            if (!IsSpawned || m_NetworkTransform == null || !UseRigidBodyForMotion)
+            if (!UseRigidBodyForMotion)
             {
-                return;
+                Debug.LogError($"[{GetType().Name}] {name} does not have {nameof(UseRigidBodyForMotion)} set! Either enable {nameof(UseRigidBodyForMotion)} on this component or do not use a {nameof(FixedJoint)} when parenting under a {nameof(NetworkObject)}.");
+                return false;
+            }
+
+            if (IsKinematic())
+            {
+                Debug.LogError($"[{GetType().Name}] {name} is currently kinematic! You cannot use a {nameof(FixedJoint)} with Kinematic bodies!");
+                return false;
+            }
+
+            if (objectToConnectTo != null)
+            {
+                if (m_IsRigidbody2D)
+                {
+                    ApplyFixedJoint2D(objectToConnectTo, positionOfConnection, connectedMassScale, massScale, useGravity, zeroVelocity);
+                }
+                else
+                {
+                    ApplyFixedJoint(objectToConnectTo, positionOfConnection, connectedMassScale, massScale, useGravity, zeroVelocity);
+                }
+
+                ParentBody = objectToConnectTo;
+                ParentBody.NetworkRigidbodyConnections.Add(this);
+                if (teleportObject)
+                {
+                    NetworkTransform.SetState(teleportDisabled: false);
+                }
+                return true;
+            }
+            return false;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void RemoveFromParentBody()
+        {
+            ParentBody.NetworkRigidbodyConnections.Remove(this);
+            ParentBody = null;
+        }
+
+        /// <summary>
+        /// Authority Only:
+        /// When invoked and already connected to an object via <see cref="FixedJoint"/> or <see cref="FixedJoint2D"/> (depending upon the type of rigid body),
+        /// this will detach from the fixed joint and destroy the fixed joint component.
+        /// </summary>
+        /// <remarks>
+        /// This is the recommended way, as opposed to parenting, to attached/detatch two rigid bodies to one another when <see cref="UseRigidBodyForMotion"/> is enabled.
+        /// </remarks>
+        public void DetachFromFixedJoint()
+        {
+            if (!HasAuthority)
+            {
+                Debug.LogError($"[{name}] Only authority can invoke {nameof(DetachFromFixedJoint)}!");
+            }
+            if (UseRigidBodyForMotion)
+            {
+                if (m_IsRigidbody2D)
+                {
+                    if (FixedJoint2D != null)
+                    {
+                        if (!m_FixedJoint2DUsingGravity)
+                        {
+                            FixedJoint2D.connectedBody.gravityScale = m_OriginalGravityScale;
+                        }
+                        FixedJoint2D.connectedBody = null;
+                        Destroy(FixedJoint2D);
+                        FixedJoint2D = null;
+                        ResetInterpolation();
+                        RemoveFromParentBody();
+                    }
+                }
+                else
+                {
+                    if (FixedJoint != null)
+                    {
+                        FixedJoint.connectedBody = null;
+                        m_Rigidbody.useGravity = m_OriginalGravitySetting;
+                        Destroy(FixedJoint);
+                        FixedJoint = null;
+                        ResetInterpolation();
+                        RemoveFromParentBody();
+                    }
+                }
             }
-            m_NetworkTransform.OnFixedUpdate();
         }
     }
 }

Runtime/Components/NetworkTransform.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Text;
 using Unity.Mathematics;
@@ -16,9 +15,13 @@ namespace Unity.Netcode.Components
     /// </summary>
     [DisallowMultipleComponent]
     [AddComponentMenu("Netcode/Network Transform")]
-    [DefaultExecutionOrder(100000)] // this is needed to catch the update time after the transform was updated by user scripts
     public class NetworkTransform : NetworkBehaviour
     {
+
+#if UNITY_EDITOR
+        internal virtual bool HideInterpolateValue => false;
+#endif
+
         #region NETWORK TRANSFORM STATE
         /// <summary>
         /// Data structure used to synchronize the <see cref="NetworkTransform"/>
@@ -922,6 +925,22 @@ namespace Unity.Netcode.Components
         #endregion
 
         #region PROPERTIES AND GENERAL METHODS
+
+
+        public enum AuthorityModes
+        {
+            Server,
+            Owner,
+        }
+#if MULTIPLAYER_SERVICES_SDK_INSTALLED
+        [Tooltip("Selects who has authority (sends state updates) over the transform. When the network topology is set to distributed authority, this always defaults to owner authority. If server (the default), then only server-side adjustments to the " +
+            "transform will be synchronized with clients. If owner (or client), then only the owner-side adjustments to the transform will be synchronized with both the server and other clients.")]
+#else
+        [Tooltip("Selects who has authority (sends state updates) over the transform. If server (the default), then only server-side adjustments to the transform will be synchronized with clients. If owner (or client), " +
+            "then only the owner-side adjustments to the transform will be synchronized with both the server and other clients.")]
+#endif
+        public AuthorityModes AuthorityMode;
+
         /// <summary>
         /// The default position change threshold value.
         /// Any changes above this threshold will be replicated.
@@ -1186,12 +1205,6 @@ namespace Unity.Netcode.Components
         /// </summary>
         public bool CanCommitToTransform { get; protected set; }
 
-        /// <summary>
-        /// Internally used by <see cref="NetworkTransform"/> to keep track of whether this <see cref="NetworkBehaviour"/> derived class instance
-        /// was instantiated on the server side or not.
-        /// </summary>
-        protected bool m_CachedIsServer; // Note: we no longer use this and are only keeping it until we decide to deprecate it
-
         /// <summary>
         /// Internally used by <see cref="NetworkTransform"/> to keep track of the <see cref="NetworkManager"/> instance assigned to this
         /// this <see cref="NetworkBehaviour"/> derived class instance.
@@ -1495,7 +1508,7 @@ namespace Unity.Netcode.Components
         /// </remarks>
         /// <param name="transformToCommit">the transform to be committed</param>
         /// <param name="dirtyTime">time it was marked dirty</param>
-        protected void TryCommitTransformToServer(Transform transformToCommit, double dirtyTime)
+        internal void TryCommitTransformToServer(Transform transformToCommit, double dirtyTime)
         {
             if (!IsSpawned)
             {
@@ -1564,12 +1577,18 @@ namespace Unity.Netcode.Components
                 NetworkLog.LogError($"[{name}] is trying to commit the transform without authority!");
                 return;
             }
+#if COM_UNITY_MODULES_PHYSICS
+            // TODO: Make this an authority flag
+            // For now, just synchronize with the NetworkRigidbodyBase UseRigidBodyForMotion
+            if (m_NetworkRigidbodyInternal != null)
+            {
+                m_UseRigidbodyForMotion = m_NetworkRigidbodyInternal.UseRigidBodyForMotion;
+            }
+#endif
 
             // If the transform has deltas (returns dirty) or if an explicitly set state is pending
             if (m_LocalAuthoritativeNetworkState.ExplicitSet || CheckForStateChange(ref m_LocalAuthoritativeNetworkState, ref transformToCommit, synchronize))
             {
-                m_LocalAuthoritativeNetworkState.LastSerializedSize = m_OldState.LastSerializedSize;
-
                 // If the state was explicitly set, then update the network tick to match the locally calculate tick
                 if (m_LocalAuthoritativeNetworkState.ExplicitSet)
                 {
@@ -1609,6 +1628,17 @@ namespace Unity.Netcode.Components
                 {
                     m_DeltaSynch = true;
                 }
+
+#if COM_UNITY_MODULES_PHYSICS
+                // We handle updating attached bodies when the "parent" body has a state update in order to keep their delta state updates tick synchronized.
+                if (m_UseRigidbodyForMotion && m_NetworkRigidbodyInternal.NetworkRigidbodyConnections.Count > 0)
+                {
+                    foreach (var childRigidbody in m_NetworkRigidbodyInternal.NetworkRigidbodyConnections)
+                    {
+                        childRigidbody.NetworkTransform.OnNetworkTick(true);
+                    }
+                }
+#endif
             }
         }
 
@@ -1688,14 +1718,45 @@ namespace Unity.Netcode.Components
 #if COM_UNITY_MODULES_PHYSICS
             var position = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetPosition() : InLocalSpace ? transformToUse.localPosition : transformToUse.position;
             var rotation = m_UseRigidbodyForMotion ? m_NetworkRigidbodyInternal.GetRotation() : InLocalSpace ? transformToUse.localRotation : transformToUse.rotation;
+
+            var positionThreshold = Vector3.one * PositionThreshold;
+            var rotationThreshold = Vector3.one * RotAngleThreshold;
+
+            if (m_UseRigidbodyForMotion)
+            {
+                positionThreshold = m_NetworkRigidbodyInternal.GetAdjustedPositionThreshold();
+                rotationThreshold = m_NetworkRigidbodyInternal.GetAdjustedRotationThreshold();
+            }
 #else
             var position = InLocalSpace ? transformToUse.localPosition : transformToUse.position;
             var rotation = InLocalSpace ? transformToUse.localRotation : transformToUse.rotation;
+            var positionThreshold =  Vector3.one * PositionThreshold;
+            var rotationThreshold = Vector3.one * RotAngleThreshold;
 #endif
             var rotAngles = rotation.eulerAngles;
             var scale = transformToUse.localScale;
             networkState.IsSynchronizing = isSynchronization;
 
+            // All of the checks below, up to the delta position checking portion, are to determine if the
+            // authority changed a property during runtime that requires a full synchronizing.
+#if COM_UNITY_MODULES_PHYSICS
+            if (InLocalSpace != networkState.InLocalSpace && !m_UseRigidbodyForMotion)
+#else
+            if (InLocalSpace != networkState.InLocalSpace)
+#endif
+            {
+                networkState.InLocalSpace = InLocalSpace;
+                isDirty = true;
+                networkState.IsTeleportingNextFrame = true;
+            }
+#if COM_UNITY_MODULES_PHYSICS
+            else if (InLocalSpace && m_UseRigidbodyForMotion)
+            {
+                // TODO: Provide more options than just FixedJoint
+                Debug.LogError($"[Rigidbody] WHen using a Rigidbody for motion, you cannot use {nameof(InLocalSpace)}! If parenting, use the integrated FixedJoint or use a Joint on Authority side.");
+            }
+#endif
+
             // Check for parenting when synchronizing and/or teleporting
             if (isSynchronization || networkState.IsTeleportingNextFrame)
             {
@@ -1705,11 +1766,13 @@ namespace Unity.Netcode.Components
                 // values are applied.
                 var hasParentNetworkObject = false;
 
+                var parentNetworkObject = (NetworkObject)null;
+
                 // If the NetworkObject belonging to this NetworkTransform instance has a parent
                 // (i.e. this handles nested NetworkTransforms under a parent at some layer above)
                 if (NetworkObject.transform.parent != null)
                 {
-                    var parentNetworkObject = NetworkObject.transform.parent.GetComponent<NetworkObject>();
+                    parentNetworkObject = NetworkObject.transform.parent.GetComponent<NetworkObject>();
 
                     // In-scene placed NetworkObjects parented under a GameObject with no
                     // NetworkObject preserve their lossyScale when synchronizing.
@@ -1730,28 +1793,25 @@ namespace Unity.Netcode.Components
                 // the NetworkTransform is using world or local space synchronization.
                 // WorldPositionStays: (always use world space)
                 // !WorldPositionStays: (always use local space)
-                if (isSynchronization)
+                // Exception: If it is an in-scene placed NetworkObject and it is parented under a GameObject
+                // then always use local space unless AutoObjectParentSync is disabled and the NetworkTransform
+                // is synchronizing in world space.
+                if (isSynchronization && networkState.IsParented)
                 {
-                    if (NetworkObject.WorldPositionStays())
+                    var parentedUnderGameObject = NetworkObject.transform.parent != null && !parentNetworkObject && NetworkObject.IsSceneObject.Value;
+                    if (NetworkObject.WorldPositionStays() && (!parentedUnderGameObject || (parentedUnderGameObject && !NetworkObject.AutoObjectParentSync && !InLocalSpace)))
                     {
                         position = transformToUse.position;
+                        networkState.InLocalSpace = false;
                     }
                     else
                     {
                         position = transformToUse.localPosition;
+                        networkState.InLocalSpace = true;
                     }
                 }
             }
 
-            // All of the checks below, up to the delta position checking portion, are to determine if the
-            // authority changed a property during runtime that requires a full synchronizing.
-            if (InLocalSpace != networkState.InLocalSpace)
-            {
-                networkState.InLocalSpace = InLocalSpace;
-                isDirty = true;
-                networkState.IsTeleportingNextFrame = true;
-            }
-
             if (Interpolate != networkState.UseInterpolation)
             {
                 networkState.UseInterpolation = Interpolate;
@@ -1798,21 +1858,21 @@ namespace Unity.Netcode.Components
             // Begin delta checks against last sent state update
             if (!UseHalfFloatPrecision)
             {
-                if (SyncPositionX && (Mathf.Abs(networkState.PositionX - position.x) >= PositionThreshold || networkState.IsTeleportingNextFrame || isAxisSync))
+                if (SyncPositionX && (Mathf.Abs(networkState.PositionX - position.x) >= positionThreshold.x || networkState.IsTeleportingNextFrame || isAxisSync))
                 {
                     networkState.PositionX = position.x;
                     networkState.HasPositionX = true;
                     isPositionDirty = true;
                 }
 
-                if (SyncPositionY && (Mathf.Abs(networkState.PositionY - position.y) >= PositionThreshold || networkState.IsTeleportingNextFrame || isAxisSync))
+                if (SyncPositionY && (Mathf.Abs(networkState.PositionY - position.y) >= positionThreshold.y || networkState.IsTeleportingNextFrame || isAxisSync))
                 {
                     networkState.PositionY = position.y;
                     networkState.HasPositionY = true;
                     isPositionDirty = true;
                 }
 
-                if (SyncPositionZ && (Mathf.Abs(networkState.PositionZ - position.z) >= PositionThreshold || networkState.IsTeleportingNextFrame || isAxisSync))
+                if (SyncPositionZ && (Mathf.Abs(networkState.PositionZ - position.z) >= positionThreshold.z || networkState.IsTeleportingNextFrame || isAxisSync))
                 {
                     networkState.PositionZ = position.z;
                     networkState.HasPositionZ = true;
@@ -1833,7 +1893,7 @@ namespace Unity.Netcode.Components
                 {
                     for (int i = 0; i < 3; i++)
                     {
-                        if (Math.Abs(position[i] - m_HalfPositionState.PreviousPosition[i]) >= PositionThreshold)
+                        if (Math.Abs(position[i] - m_HalfPositionState.PreviousPosition[i]) >= positionThreshold[i])
                         {
                             isPositionDirty = i == 0 ? SyncPositionX : i == 1 ? SyncPositionY : SyncPositionZ;
                             if (!isPositionDirty)
@@ -1928,21 +1988,21 @@ namespace Unity.Netcode.Components
 
             if (!UseQuaternionSynchronization)
             {
-                if (SyncRotAngleX && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleX, rotAngles.x)) >= RotAngleThreshold || networkState.IsTeleportingNextFrame || isAxisSync))
+                if (SyncRotAngleX && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleX, rotAngles.x)) >= rotationThreshold.x || networkState.IsTeleportingNextFrame || isAxisSync))
                 {
                     networkState.RotAngleX = rotAngles.x;
                     networkState.HasRotAngleX = true;
                     isRotationDirty = true;
                 }
 
-                if (SyncRotAngleY && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleY, rotAngles.y)) >= RotAngleThreshold || networkState.IsTeleportingNextFrame || isAxisSync))
+                if (SyncRotAngleY && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleY, rotAngles.y)) >= rotationThreshold.y || networkState.IsTeleportingNextFrame || isAxisSync))
                 {
                     networkState.RotAngleY = rotAngles.y;
                     networkState.HasRotAngleY = true;
                     isRotationDirty = true;
                 }
 
-                if (SyncRotAngleZ && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleZ, rotAngles.z)) >= RotAngleThreshold || networkState.IsTeleportingNextFrame || isAxisSync))
+                if (SyncRotAngleZ && (Mathf.Abs(Mathf.DeltaAngle(networkState.RotAngleZ, rotAngles.z)) >= rotationThreshold.z || networkState.IsTeleportingNextFrame || isAxisSync))
                 {
                     networkState.RotAngleZ = rotAngles.z;
                     networkState.HasRotAngleZ = true;
@@ -1959,7 +2019,7 @@ namespace Unity.Netcode.Components
                     var previousRotation = networkState.Rotation.eulerAngles;
                     for (int i = 0; i < 3; i++)
                     {
-                        if (Mathf.Abs(Mathf.DeltaAngle(previousRotation[i], rotAngles[i])) >= RotAngleThreshold)
+                        if (Mathf.Abs(Mathf.DeltaAngle(previousRotation[i], rotAngles[i])) >= rotationThreshold[i])
                         {
                             isRotationDirty = true;
                             break;
@@ -1968,7 +2028,7 @@ namespace Unity.Netcode.Components
                 }
                 if (isRotationDirty)
                 {
-                    networkState.Rotation = InLocalSpace ? transformToUse.localRotation : transformToUse.rotation;
+                    networkState.Rotation = rotation;
                     networkState.HasRotAngleX = true;
                     networkState.HasRotAngleY = true;
                     networkState.HasRotAngleZ = true;
@@ -2067,15 +2127,31 @@ namespace Unity.Netcode.Components
         /// Authority subscribes to network tick events and will invoke
         /// <see cref="OnUpdateAuthoritativeState(ref Transform)"/> each network tick.
         /// </summary>
-        private void OnNetworkTick()
+        private void OnNetworkTick(bool isCalledFromParent = false)
         {
+            // If not active, then ignore the update
+            if (!gameObject.activeInHierarchy)
+            {
+                return;
+            }
+
             // As long as we are still authority
             if (CanCommitToTransform)
             {
                 if (m_CachedNetworkManager.DistributedAuthorityMode && !IsOwner)
                 {
                     Debug.LogError($"Non-owner Client-{m_CachedNetworkManager.LocalClientId} is being updated by network tick still!!!!");
+                    return;
                 }
+
+#if COM_UNITY_MODULES_PHYSICS
+                // Let the parent handle the updating of this to keep the two synchronized
+                if (!isCalledFromParent && m_UseRigidbodyForMotion && m_NetworkRigidbodyInternal.ParentBody != null && !m_LocalAuthoritativeNetworkState.IsTeleportingNextFrame)
+                {
+                    return;
+                }
+#endif
+
                 // Update any changes to the transform
                 var transformSource = transform;
                 OnUpdateAuthoritativeState(ref transformSource);
@@ -2086,10 +2162,9 @@ namespace Unity.Netcode.Components
                 m_TargetPosition = GetSpaceRelativePosition();
 #endif
             }
-            else // If we are no longer authority, unsubscribe to the tick event
+            else // If we are no longer authority, unsubscribe to the tick event          
-            if (NetworkManager != null && NetworkManager.NetworkTickSystem != null)
             {
-                NetworkManager.NetworkTickSystem.Tick -= OnNetworkTick;
+                DeregisterForTickUpdate(this);
             }
         }
         #endregion
@@ -2114,11 +2189,24 @@ namespace Unity.Netcode.Components
 
         internal bool LogMotion;
 
+        protected virtual void OnTransformUpdated()
+        {
+
+        }
+
         /// <summary>
         /// Applies the authoritative state to the transform
         /// </summary>
-        private void ApplyAuthoritativeState()
+        protected internal void ApplyAuthoritativeState()
         {
+#if COM_UNITY_MODULES_PHYSICS
+            // TODO: Make this an authority flag
+            // For now, just synchronize with the NetworkRigidbodyBase UseRigidBodyForMotion
+            if (m_NetworkRigidbodyInternal != null)
+            {
+                m_UseRigidbodyForMotion = m_NetworkRigidbodyInternal.UseRigidBodyForMotion;
+            }
+#endif
             var networkState = m_LocalAuthoritativeNetworkState;
             // The m_CurrentPosition, m_CurrentRotation, and m_CurrentScale values are continually updated
             // at the end of this method and assure that when not interpolating the non-authoritative side
@@ -2313,6 +2401,7 @@ namespace Unity.Netcode.Components
                 }
                 transform.localScale = m_CurrentScale;
             }
+            OnTransformUpdated();
         }
 
         /// <summary>
@@ -2524,6 +2613,8 @@ namespace Unity.Netcode.Components
             {
                 AddLogEntry(ref newState, NetworkObject.OwnerClientId);
             }
+
+            OnTransformUpdated();
         }
 
         /// <summary>
@@ -2691,6 +2782,11 @@ namespace Unity.Netcode.Components
 
         }
 
+        protected virtual void OnBeforeUpdateTransformState()
+        {
+
+        }
+
         internal bool LogStateUpdate;
         /// <summary>
         /// Only non-authoritative instances should invoke this method
@@ -2731,6 +2827,10 @@ namespace Unity.Netcode.Components
                 }
                 Debug.Log(builder);
             }
+
+            // Notification prior to applying a state update
+            OnBeforeUpdateTransformState();
+
             // Apply the new state
             ApplyUpdatedState(newState);
 
@@ -2842,12 +2942,6 @@ namespace Unity.Netcode.Components
         /// <inheritdoc/>
         public override void OnNetworkSpawn()
         {
-            ///////////////////////////////////////////////////////////////
-            // NOTE: Legacy and no longer used (candidates for deprecation)
-            m_CachedIsServer = IsServer;
-            ///////////////////////////////////////////////////////////////
-
-            // Started using this again to avoid the getter processing cost of NetworkBehaviour.NetworkManager
             m_CachedNetworkManager = NetworkManager;
 
             Initialize();
@@ -2860,6 +2954,13 @@ namespace Unity.Netcode.Components
 
         private void CleanUpOnDestroyOrDespawn()
         {
+
+#if COM_UNITY_MODULES_PHYSICS
+            var forUpdate = !m_UseRigidbodyForMotion;
+#else
+            var forUpdate = true;
+#endif
+            NetworkManager?.NetworkTransformRegistration(this, forUpdate, false);
             DeregisterForTickUpdate(this);
             CanCommitToTransform = false;
         }
@@ -2918,7 +3019,7 @@ namespace Unity.Netcode.Components
             m_ScaleInterpolator.ResetTo(transform.localScale, serverTime);
             m_RotationInterpolator.ResetTo(rotation, serverTime);
         }
-
+        private NetworkObject m_CachedNetworkObject;
         /// <summary>
         /// The internal initialzation method to allow for internal API adjustments
         /// </summary>
@@ -2929,8 +3030,14 @@ namespace Unity.Netcode.Components
             {
                 return;
             }
-
+            m_CachedNetworkObject = NetworkObject;
+            if (m_CachedNetworkManager && m_CachedNetworkManager.DistributedAuthorityMode)
+            {
+                AuthorityMode = AuthorityModes.Owner;
+            }
             CanCommitToTransform = IsServerAuthoritative() ? IsServer : IsOwner;
+
+
             var currentPosition = GetSpaceRelativePosition();
             var currentRotation = GetSpaceRelativeRotation();
 
@@ -2952,20 +3059,29 @@ namespace Unity.Netcode.Components
                 m_NetworkRigidbodyInternal.SetPosition(currentPosition);
                 m_NetworkRigidbodyInternal.SetRotation(currentRotation);
             }
+
+            var forUpdate = !m_UseRigidbodyForMotion;
+#else
+            var forUpdate = true;
 #endif
+            m_LocalAuthoritativeNetworkState.SynchronizeBaseHalfFloat = false;
 
             if (CanCommitToTransform)
             {
+                // Make sure authority doesn't get added to updates (no need to do this on the authority side)
+                m_CachedNetworkManager.NetworkTransformRegistration(this, forUpdate, false);
                 if (UseHalfFloatPrecision)
                 {
                     m_HalfPositionState = new NetworkDeltaPosition(currentPosition, m_CachedNetworkManager.ServerTime.Tick, math.bool3(SyncPositionX, SyncPositionY, SyncPositionZ));
+                    m_LocalAuthoritativeNetworkState.SynchronizeBaseHalfFloat = isOwnershipChange;
+                    SetState(teleportDisabled: false);
                 }
+
                 m_CurrentPosition = currentPosition;
                 m_TargetPosition = currentPosition;
 
                 RegisterForTickUpdate(this);
 
-                m_LocalAuthoritativeNetworkState.SynchronizeBaseHalfFloat = false;
                 if (UseHalfFloatPrecision && isOwnershipChange && !IsServerAuthoritative() && Interpolate)
                 {
                     m_HalfFloatTargetTickOwnership = m_CachedNetworkManager.ServerTime.Tick;
@@ -2973,18 +3089,17 @@ namespace Unity.Netcode.Components
             }
             else
             {
+                // Non-authority needs to be added to updates for interpolation and applying state purposes
+                m_CachedNetworkManager.NetworkTransformRegistration(this, forUpdate, true);
                 // Remove this instance from the tick update
                 DeregisterForTickUpdate(this);
-
                 ResetInterpolatedStateToCurrentAuthoritativeState();
-                m_LocalAuthoritativeNetworkState.SynchronizeBaseHalfFloat = false;
                 m_CurrentPosition = currentPosition;
                 m_TargetPosition = currentPosition;
                 m_CurrentScale = transform.localScale;
                 m_TargetScale = transform.localScale;
                 m_CurrentRotation = currentRotation;
                 m_TargetRotation = currentRotation.eulerAngles;
-
             }
             OnInitialize(ref m_LocalAuthoritativeNetworkState);
         }
@@ -3233,7 +3348,7 @@ namespace Unity.Netcode.Components
             {
                 var serverTime = m_CachedNetworkManager.ServerTime;
                 var cachedServerTime = serverTime.Time;
-                var offset = 0f;
+                //var offset = (float)serverTime.TickOffset;
 #if COM_UNITY_MODULES_PHYSICS
                 var cachedDeltaTime = m_UseRigidbodyForMotion ? m_CachedNetworkManager.RealTimeProvider.FixedDeltaTime : m_CachedNetworkManager.RealTimeProvider.DeltaTime;
 #else
@@ -3242,18 +3357,16 @@ namespace Unity.Netcode.Components
                 // With owner authoritative mode, non-authority clients can lag behind
                 // by more than 1 tick period of time. The current "solution" for now
                 // is to make their cachedRenderTime run 2 ticks behind.
-#if COM_UNITY_MODULES_PHYSICS
+                var ticksAgo = (!IsServerAuthoritative() && !IsServer) || m_CachedNetworkManager.DistributedAuthorityMode ? 2 : 1;
-                var ticksAgo = (!IsServerAuthoritative() && !IsServer) || m_UseRigidbodyForMotion ? 2 : 1;
+                // TODO: We need an RTT that updates regularly and not only when the client sends packets
-#else
+                //if (m_CachedNetworkManager.DistributedAuthorityMode)
-                var ticksAgo = (!IsServerAuthoritative() && !IsServer) ? 2 : 1;
+                //{
-#endif
+                //ticksAgo = m_CachedNetworkManager.CMBServiceConnection ? 2 : 3;
-                if (m_CachedNetworkManager.DistributedAuthorityMode)
+                //ticksAgo = Mathf.Max(ticksAgo, (int)m_NetworkTransformTickRegistration.TicksAgo);
-                {
+                //offset = m_NetworkTransformTickRegistration.Offset;
-                    ticksAgo = Mathf.Max(ticksAgo, (int)m_NetworkTransformTickRegistration.TicksAgo);
+                //}
-                    offset = m_NetworkTransformTickRegistration.Offset;
-                }
 
-                var cachedRenderTime = serverTime.TimeTicksAgo(ticksAgo, offset).Time;
+                var cachedRenderTime = serverTime.TimeTicksAgo(ticksAgo).Time;
 
                 // Now only update the interpolators for the portions of the transform being synchronized
                 if (SynchronizePosition)
@@ -3282,7 +3395,7 @@ namespace Unity.Netcode.Components
         /// If you override this method, be sure that:
         /// - Non-authority always invokes this base class method.
         /// </remarks>
-        protected virtual void Update()
+        public virtual void OnUpdate()
         {
             // If not spawned or this instance has authority, exit early
 #if COM_UNITY_MODULES_PHYSICS
@@ -3303,11 +3416,12 @@ namespace Unity.Netcode.Components
 
 
 #if COM_UNITY_MODULES_PHYSICS
+
         /// <summary>
         /// When paired with a NetworkRigidbody and NetworkRigidbody.UseRigidBodyForMotion is enabled,
         /// this will be invoked during <see cref="NetworkRigidbody.FixedUpdate"/>.
         /// </summary>
-        internal void OnFixedUpdate()
+        public virtual void OnFixedUpdate()
         {
             // If not spawned or this instance has authority, exit early
             if (!m_UseRigidbodyForMotion || !IsSpawned || CanCommitToTransform)
@@ -3326,64 +3440,107 @@ namespace Unity.Netcode.Components
 #endif
 
         /// <summary>
-        /// Override this method and return false to switch to owner authoritative mode
+        /// Determines whether the <see cref="NetworkTransform"/> is <see cref="AuthorityModes.Server"/> or <see cref="AuthorityModes.Owner"/> based on the <see cref="AuthorityMode"/> property.
+        /// You can override this method to control this logic. 
         /// </summary>
-        /// <returns>(<see cref="true"/> or <see cref="false"/>) where when false it runs as owner-client authoritative</returns>
+        /// <returns><see cref="true"/> or <see cref="false"/></returns>
         protected virtual bool OnIsServerAuthoritative()
         {
-            if (m_CachedNetworkManager)
+            return AuthorityMode == AuthorityModes.Server;
-            {
-                return !m_CachedNetworkManager.DistributedAuthorityMode;
-            }
-            return true;
         }
 
         /// <summary>
         /// Method to determine if this <see cref="NetworkTransform"/> instance is owner or server authoritative.
         /// </summary>
         /// <remarks>
-        /// Used by <see cref="NetworkRigidbody"/> to determines if this is server or owner authoritative.
+        /// When using a <see cref="NetworkTopologyTypes.DistributedAuthority"/> <see cref="NetworkConfig.NetworkTopology"/>, this will always be viewed as a <see cref="AuthorityModes.Owner"/> authoritative motion model.
         /// </remarks>
         /// <returns><see cref="true"/> or <see cref="false"/></returns>
         public bool IsServerAuthoritative()
         {
-            return OnIsServerAuthoritative();
+            if (m_CachedNetworkManager && m_CachedNetworkManager.DistributedAuthorityMode)
+            {
+                return false;
+            }
+            else
+            {
+                return OnIsServerAuthoritative();
+            }
         }
 
         #endregion
 
         #region MESSAGE HANDLING
+
+        internal NetworkTransformState InboundState = new NetworkTransformState();
+        internal NetworkTransformState OutboundState
+        {
+            get
+            {
+                return m_LocalAuthoritativeNetworkState;
+            }
+        }
+
         /// <summary>
         /// Invoked by <see cref="NetworkTransformMessage"/> to update the transform state
         /// </summary>
         /// <param name="networkTransformState"></param>
-        internal void TransformStateUpdate(ref NetworkTransformState networkTransformState, ulong senderId)
+        internal void TransformStateUpdate(ulong senderId)
         {
             if (CanCommitToTransform)
             {
-                Debug.LogError($"Authority receiving transform update from Client-{senderId}!");
+                // TODO: Investigate where this state should be applied or just discarded.
+                // For now, discard the state if we assumed ownership.
+                return;
             }
             // Store the previous/old state
             m_OldState = m_LocalAuthoritativeNetworkState;
 
             // Assign the new incoming state
-            m_LocalAuthoritativeNetworkState = networkTransformState;
+            m_LocalAuthoritativeNetworkState = InboundState;
 
             // Apply the state update
             OnNetworkStateChanged(m_OldState, m_LocalAuthoritativeNetworkState);
         }
 
+        // Used to send outbound messages
+        private NetworkTransformMessage m_OutboundMessage = new NetworkTransformMessage();
+
+
+        internal int SerializeMessage(FastBufferWriter writer, int targetVersion)
+        {
+            var networkObject = NetworkObject;
+            var position = writer.Position;
+            BytePacker.WriteValueBitPacked(writer, NetworkObjectId);
+            BytePacker.WriteValueBitPacked(writer, (int)NetworkBehaviourId);
+            writer.WriteNetworkSerializable(m_LocalAuthoritativeNetworkState);
+            if (m_CachedNetworkManager.DistributedAuthorityMode)
+            {
+                BytePacker.WriteValuePacked(writer, networkObject.Observers.Count - 1);
+
+                foreach (var targetId in networkObject.Observers)
+                {
+                    if (OwnerClientId == targetId)
+                    {
+                        continue;
+                    }
+                    BytePacker.WriteValuePacked(writer, targetId);
+                }
+            }
+            return writer.Position - position;
+        }
+
         /// <summary>
         /// Invoked by the authoritative instance to sends a <see cref="NetworkTransformMessage"/> containing the <see cref="NetworkTransformState"/>
         /// </summary>
         private void UpdateTransformState()
         {
-            if (m_CachedNetworkManager.ShutdownInProgress)
+            if (m_CachedNetworkManager.ShutdownInProgress || (m_CachedNetworkManager.DistributedAuthorityMode && m_CachedNetworkObject.Observers.Count - 1 == 0))
             {
                 return;
             }
 
-            bool isServerAuthoritative = OnIsServerAuthoritative();
+            bool isServerAuthoritative = IsServerAuthoritative();
             if (isServerAuthoritative && !IsServer)
             {
                 Debug.LogError($"Server authoritative {nameof(NetworkTransform)} can only be updated by the server!");
@@ -3393,17 +3550,7 @@ namespace Unity.Netcode.Components
                 Debug.LogError($"Owner authoritative {nameof(NetworkTransform)} can only be updated by the owner!");
             }
             var customMessageManager = m_CachedNetworkManager.CustomMessagingManager;
-
+            m_OutboundMessage.NetworkTransform = this;
-            var networkTransformMessage = new NetworkTransformMessage()
-            {
-                NetworkObjectId = NetworkObjectId,
-                NetworkBehaviourId = NetworkBehaviourId,
-                State = m_LocalAuthoritativeNetworkState,
-                DistributedAuthorityMode = m_CachedNetworkManager.DistributedAuthorityMode,
-                // Don't populate if we are the DAHost as we send directly to each client
-                TargetIds = m_CachedNetworkManager.DistributedAuthorityMode && !m_CachedNetworkManager.DAHost ? NetworkObject.Observers.Where((c) => c != m_CachedNetworkManager.LocalClientId).ToArray() : null,
-            };
-
 
             // Determine what network delivery method to use:
             // When to send reliable packets:
@@ -3429,14 +3576,15 @@ namespace Unity.Netcode.Components
                     {
                         continue;
                     }
-                    NetworkManager.MessageManager.SendMessage(ref networkTransformMessage, networkDelivery, clientId);
+                    NetworkManager.MessageManager.SendMessage(ref m_OutboundMessage, networkDelivery, clientId);
                 }
             }
             else
             {
                 // Clients (owner authoritative) send messages to the server-host
-                NetworkManager.MessageManager.SendMessage(ref networkTransformMessage, networkDelivery, NetworkManager.ServerClientId);
+                NetworkManager.MessageManager.SendMessage(ref m_OutboundMessage, networkDelivery, NetworkManager.ServerClientId);
             }
+            m_LocalAuthoritativeNetworkState.LastSerializedSize = m_OutboundMessage.BytesWritten;
         }
         #endregion
 
@@ -3509,7 +3657,9 @@ namespace Unity.Netcode.Components
 
             internal float TicksAgoInSeconds()
             {
-                return Mathf.Max(1.0f, TicksAgo) * m_TickFrequency;
+                return 2 * m_TickFrequency;
+                // TODO: We need an RTT that updates regularly and not just when the client sends packets
+                //return Mathf.Max(1.0f, TicksAgo) * m_TickFrequency;
             }
 
             /// <summary>
@@ -3518,25 +3668,26 @@ namespace Unity.Netcode.Components
             /// </summary>
             private void TickUpdate()
             {
-                if (m_UnityTransport != null)
+                // TODO: We need an RTT that updates regularly and not just when the client sends packets
-                {
+                //if (m_UnityTransport != null)
-                    // Determine the desired ticks ago by the RTT (this really should be the combination of the
+                //{
-                    // authority and non-authority 1/2 RTT but in the end anything beyond 300ms is considered very poor
+                //    // Determine the desired ticks ago by the RTT (this really should be the combination of the
-                    // network quality so latent interpolation is going to be expected).
+                //    // authority and non-authority 1/2 RTT but in the end anything beyond 300ms is considered very poor
-                    var rtt = Mathf.Max(m_TickInMS, m_UnityTransport.GetCurrentRtt(NetworkManager.ServerClientId));
+                //    // network quality so latent interpolation is going to be expected).
-                    m_TicksAgoSamples[m_TickSampleIndex] = Mathf.Max(1, (int)(rtt * m_TickFrequency));
+                //    var rtt = Mathf.Max(m_TickInMS, m_UnityTransport.GetCurrentRtt(NetworkManager.ServerClientId));
-                    var tickAgoSum = 0.0f;
+                //    m_TicksAgoSamples[m_TickSampleIndex] = Mathf.Max(1, (int)(rtt * m_TickFrequency));
-                    foreach (var tickAgo in m_TicksAgoSamples)
+                //    var tickAgoSum = 0.0f;
-                    {
+                //    foreach (var tickAgo in m_TicksAgoSamples)
-                        tickAgoSum += tickAgo;
+                //    {
-                    }
+                //        tickAgoSum += tickAgo;
-                    m_PreviousTicksAgo = TicksAgo;
+                //    }
-                    TicksAgo = Mathf.Lerp(m_PreviousTicksAgo, tickAgoSum / m_TickRate, m_TickFrequency);
+                //    m_PreviousTicksAgo = TicksAgo;
-                    m_TickSampleIndex = (m_TickSampleIndex + 1) % m_TickRate;
+                //    TicksAgo = Mathf.Lerp(m_PreviousTicksAgo, tickAgoSum / m_TickRate, m_TickFrequency);
-                    // Get the partial tick value for when this is all calculated to provide an offset for determining
+                //    m_TickSampleIndex = (m_TickSampleIndex + 1) % m_TickRate;
-                    // the relative starting interpolation point for the next update
+                //    // Get the partial tick value for when this is all calculated to provide an offset for determining
-                    Offset = m_OffsetTickFrequency * (Mathf.Max(2, TicksAgo) - (int)TicksAgo);
+                //    // the relative starting interpolation point for the next update
-                }
+                //    Offset = m_OffsetTickFrequency * (Mathf.Max(2, TicksAgo) - (int)TicksAgo);
+                //}
 
                 // TODO FIX: The local NetworkTickSystem can invoke with the same network tick as before
                 if (m_NetworkManager.ServerTime.Tick <= m_LastTick)
@@ -3556,13 +3707,13 @@ namespace Unity.Netcode.Components
 
             private UnityTransport m_UnityTransport;
             private float m_TickFrequency;
-            private float m_OffsetTickFrequency;
+            //private float m_OffsetTickFrequency;
-            private ulong m_TickInMS;
+            //private ulong m_TickInMS;
-            private int m_TickSampleIndex;
+            //private int m_TickSampleIndex;
             private int m_TickRate;
             public float TicksAgo { get; private set; }
-            public float Offset { get; private set; }
+            //public float Offset { get; private set; }
-            private float m_PreviousTicksAgo;
+            //private float m_PreviousTicksAgo;
 
             private List<float> m_TicksAgoSamples = new List<float>();
 
@@ -3573,19 +3724,19 @@ namespace Unity.Netcode.Components
                 networkManager.NetworkTickSystem.Tick += m_NetworkTickUpdate;
                 m_TickRate = (int)m_NetworkManager.NetworkConfig.TickRate;
                 m_TickFrequency = 1.0f / m_TickRate;
-                // For the offset, it uses the fractional remainder of the tick to determine the offset.
+                //// For the offset, it uses the fractional remainder of the tick to determine the offset.
-                // In order to keep within tick boundaries, we increment the tick rate by 1 to assure it
+                //// In order to keep within tick boundaries, we increment the tick rate by 1 to assure it
-                // will always be < the tick frequency.
+                //// will always be < the tick frequency.
-                m_OffsetTickFrequency = 1.0f / (m_TickRate + 1);
+                //m_OffsetTickFrequency = 1.0f / (m_TickRate + 1);
-                m_TickInMS = (ulong)(1000 * m_TickFrequency);
+                //m_TickInMS = (ulong)(1000 * m_TickFrequency);
-                m_UnityTransport = m_NetworkManager.NetworkConfig.NetworkTransport as UnityTransport;
+                //m_UnityTransport = m_NetworkManager.NetworkConfig.NetworkTransport as UnityTransport;
-                // Fill the sample with a starting value of 1
+                //// Fill the sample with a starting value of 1
-                for (int i = 0; i < m_TickRate; i++)
+                //for (int i = 0; i < m_TickRate; i++)
-                {
+                //{
-                    m_TicksAgoSamples.Add(1f);
+                //    m_TicksAgoSamples.Add(1f);
-                }
+                //}
-                TicksAgo = 1f;
+                TicksAgo = 2f;
-                m_PreviousTicksAgo = 1f;
+                //m_PreviousTicksAgo = 1f;
                 if (networkManager.IsServer)
                 {
                     networkManager.OnServerStopped += OnNetworkManagerStopped;

Runtime/Components/QuaternionCompressor.cs

@@ -14,7 +14,7 @@ namespace Unity.Netcode
     /// 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.
+    /// Using the largest number avoids potential loss of precision in the smallest three values.
     /// </remarks>
     public static class QuaternionCompressor
     {

Runtime/Configuration/NetworkConfig.cs

@@ -149,8 +149,8 @@ namespace Unity.Netcode
         /// </summary>
         public const int RttWindowSize = 64; // number of slots to use for RTT computations (max number of in-flight packets)
 
-        [Tooltip("Determines if the network session will run in client-server or distributed authority mode.")]
+        [Tooltip("Determines whether to use the client-server or distributed authority network topology.")]
-        public SessionModeTypes SessionMode;
+        public NetworkTopologyTypes NetworkTopology;
 
         [HideInInspector]
         public bool UseCMBService;
@@ -158,6 +158,12 @@ namespace Unity.Netcode
         [Tooltip("When enabled (default), the player prefab will automatically be spawned (client-side) upon the client being approved and synchronized.")]
         public bool AutoSpawnPlayerPrefabClientSide = true;
 
+#if MULTIPLAYER_TOOLS
+        public bool NetworkMessageMetrics = true;
+#endif
+
+        public bool NetworkProfilingMetrics = true;
+
         /// <summary>
         /// Returns a base64 encoded version of the configuration
         /// </summary>

Runtime/Connection/NetworkClient.cs

@@ -1,15 +1,8 @@
-using System.Collections.Generic;
 using UnityEngine;
 
 namespace Unity.Netcode
 {
 
-    public enum SessionModeTypes
-    {
-        ClientServer,
-        DistributedAuthority
-    }
-
     /// <summary>
     /// A NetworkClient
     /// </summary>
@@ -41,7 +34,7 @@ namespace Unity.Netcode
         /// </summary>
         internal bool IsApproved { get; set; }
 
-        public SessionModeTypes SessionModeType { get; internal set; }
+        public NetworkTopologyTypes NetworkTopologyType { get; internal set; }
 
         public bool DAHost { get; internal set; }
 
@@ -61,9 +54,9 @@ namespace Unity.Netcode
         public NetworkObject PlayerObject;
 
         /// <summary>
-        /// The list of NetworkObject's owned by this client instance
+        /// The NetworkObject's owned by this client instance
         /// </summary>
-        public List<NetworkObject> OwnedObjects => IsConnected ? SpawnManager.GetClientOwnedObjects(ClientId) : new List<NetworkObject>();
+        public NetworkObject[] OwnedObjects => IsConnected ? SpawnManager.GetClientOwnedObjects(ClientId) : new NetworkObject[] { };
 
         internal NetworkSpawnManager SpawnManager { get; private set; }
 
@@ -77,9 +70,9 @@ namespace Unity.Netcode
             if (networkManager != null)
             {
                 SpawnManager = networkManager.SpawnManager;
-                SessionModeType = networkManager.NetworkConfig.SessionMode;
+                NetworkTopologyType = networkManager.NetworkConfig.NetworkTopology;
 
-                if (SessionModeType == SessionModeTypes.DistributedAuthority)
+                if (NetworkTopologyType == NetworkTopologyTypes.DistributedAuthority)
                 {
                     DAHost = IsClient && IsServer;
 

Runtime/Connection/NetworkConnectionManager.cs

@@ -1229,6 +1229,8 @@ namespace Unity.Netcode
                 var message = new ClientDisconnectedMessage { ClientId = clientId };
                 MessageManager?.SendMessage(ref message, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
 
+                // Used for testing/validation purposes only
+#if ENABLE_DAHOST_AUTOPROMOTE_SESSION_OWNER
                 if (NetworkManager.DistributedAuthorityMode && !NetworkManager.ShutdownInProgress && NetworkManager.IsListening)
                 {
                     var newSessionOwner = NetworkManager.LocalClientId;
@@ -1259,6 +1261,7 @@ namespace Unity.Netcode
                     MessageManager?.SendMessage(ref sessionOwnerMessage, NetworkDelivery.ReliableFragmentedSequenced, ConnectedClientIds);
                     NetworkManager.SetSessionOwner(newSessionOwner);
                 }
+#endif
             }
 
             // If the client ID transport map exists

Runtime/Core/NetworkBehaviour.cs

@@ -660,16 +660,69 @@ namespace Unity.Netcode
         /// <param name="despawnTick">the future network tick that the <see cref="NetworkObject"/> will be despawned on non-authoritative instances</param>
         public virtual void OnDeferringDespawn(int despawnTick) { }
 
+        /// Gets called after the <see cref="NetworkObject"/> is spawned. No NetworkBehaviours associated with the NetworkObject will have had <see cref="OnNetworkSpawn"/> invoked yet.
+        /// A reference to <see cref="NetworkManager"/> is passed in as a parameter to determine the context of execution (IsServer/IsClient)
+        /// </summary>
+        /// <remarks>
+        /// <param name="networkManager">a ref to the <see cref="NetworkManager"/> since this is not yet set on the <see cref="NetworkBehaviour"/></param>
+        /// The <see cref="NetworkBehaviour"/> will not have anything assigned to it at this point in time.
+        /// Settings like ownership, NetworkBehaviourId, NetworkManager, and most other spawn related properties will not be set.
+        /// This can be used to handle things like initializing/instantiating a NetworkVariable or the like.
+        /// </remarks>
+        protected virtual void OnNetworkPreSpawn(ref NetworkManager networkManager) { }
+
         /// <summary>
         /// Gets called when the <see cref="NetworkObject"/> gets spawned, message handlers are ready to be registered and the network is setup.
         /// </summary>
         public virtual void OnNetworkSpawn() { }
 
+        /// <summary>
+        /// Gets called after the <see cref="NetworkObject"/> is spawned. All NetworkBehaviours associated with the NetworkObject will have had <see cref="OnNetworkSpawn"/> invoked.
+        /// </summary>
+        /// <remarks>
+        /// Will be invoked on each <see cref="NetworkBehaviour"/> associated with the <see cref="NetworkObject"/> being spawned.
+        /// All associated <see cref="NetworkBehaviour"/> components will have had <see cref="OnNetworkSpawn"/> invoked on the spawned <see cref="NetworkObject"/>.
+        /// </remarks>
+        protected virtual void OnNetworkPostSpawn() { }
+
+        /// <summary>
+        /// [Client-Side Only]
+        /// When a new client joins it is synchronized with all spawned NetworkObjects and scenes loaded for the session joined. At the end of the synchronization process, when all
+        /// <see cref="NetworkObject"/>s and scenes (if scene management is enabled) have finished synchronizing, all NetworkBehaviour components associated with spawned <see cref="NetworkObject"/>s
+        /// will have this method invoked.
+        /// </summary>
+        /// <remarks>
+        /// This can be used to handle post synchronization actions where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
+        /// This is only invoked on clients during a client-server network topology session.
+        /// </remarks>
+        protected virtual void OnNetworkSessionSynchronized() { }
+
+        /// <summary>
+        /// [Client & Server Side]
+        /// When a scene is loaded an in-scene placed NetworkObjects are all spawned, this method is invoked on all of the newly spawned in-scene placed NetworkObjects.
+        /// </summary>
+        /// <remarks>
+        /// This can be used to handle post scene loaded actions for in-scene placed NetworkObjcts where you might need to access a different NetworkObject and/or NetworkBehaviour not local to the current NetworkObject context.
+        /// </remarks>
+        protected virtual void OnInSceneObjectsSpawned() { }
+
         /// <summary>
         /// Gets called when the <see cref="NetworkObject"/> gets despawned. Is called both on the server and clients.
         /// </summary>
         public virtual void OnNetworkDespawn() { }
 
+        internal void NetworkPreSpawn(ref NetworkManager networkManager)
+        {
+            try
+            {
+                OnNetworkPreSpawn(ref networkManager);
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+            }
+        }
+
         internal void InternalOnNetworkSpawn()
         {
             IsSpawned = true;
@@ -699,6 +752,42 @@ namespace Unity.Netcode
             }
         }
 
+        internal void NetworkPostSpawn()
+        {
+            try
+            {
+                OnNetworkPostSpawn();
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+            }
+        }
+
+        internal void NetworkSessionSynchronized()
+        {
+            try
+            {
+                OnNetworkSessionSynchronized();
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+            }
+        }
+
+        internal void InSceneNetworkObjectsSpawned()
+        {
+            try
+            {
+                OnInSceneObjectsSpawned();
+            }
+            catch (Exception e)
+            {
+                Debug.LogException(e);
+            }
+        }
+
         internal void InternalOnNetworkDespawn()
         {
             IsSpawned = false;
@@ -861,7 +950,16 @@ namespace Unity.Netcode
                 // during OnNetworkSpawn has been sent and needs to be cleared
                 for (int i = 0; i < NetworkVariableFields.Count; i++)
                 {
-                    NetworkVariableFields[i].ResetDirty();
+                    var networkVariable = NetworkVariableFields[i];
+                    if (networkVariable.IsDirty())
+                    {
+                        if (networkVariable.CanSend())
+                        {
+                            networkVariable.UpdateLastSentTime();
+                            networkVariable.ResetDirty();
+                            networkVariable.SetDirty(false);
+                        }
+                    }
                 }
             }
             else
@@ -869,7 +967,16 @@ namespace Unity.Netcode
                 // mark any variables we wrote as no longer dirty
                 for (int i = 0; i < NetworkVariableIndexesToReset.Count; i++)
                 {
-                    NetworkVariableFields[NetworkVariableIndexesToReset[i]].ResetDirty();
+                    var networkVariable = NetworkVariableFields[NetworkVariableIndexesToReset[i]];
+                    if (networkVariable.IsDirty())
+                    {
+                        if (networkVariable.CanSend())
+                        {
+                            networkVariable.UpdateLastSentTime();
+                            networkVariable.ResetDirty();
+                            networkVariable.SetDirty(false);
+                        }
+                    }
                 }
             }
 
@@ -912,7 +1019,10 @@ namespace Unity.Netcode
                     networkVariable = NetworkVariableFields[k];
                     if (networkVariable.IsDirty() && networkVariable.CanClientRead(targetClientId))
                     {
-                        shouldSend = true;
+                        if (networkVariable.CanSend())
+                        {
+                            shouldSend = true;
+                        }
                         break;
                     }
                 }
@@ -968,9 +1078,16 @@ namespace Unity.Netcode
             // TODO: There should be a better way by reading one dirty variable vs. 'n'
             for (int i = 0; i < NetworkVariableFields.Count; i++)
             {
-                if (NetworkVariableFields[i].IsDirty())
+                var networkVariable = NetworkVariableFields[i];
+                if (networkVariable.IsDirty())
                 {
-                    return true;
+                    if (networkVariable.CanSend())
+                    {
+                        return true;
+                    }
+                    // If it's dirty but can't be sent yet, we have to keep monitoring it until one of the
+                    // conditions blocking its send changes.
+                    NetworkManager.BehaviourUpdater.AddForUpdate(NetworkObject);
                 }
             }
 
@@ -1179,6 +1296,11 @@ namespace Unity.Netcode
 
         }
 
+        public virtual void OnReanticipate(double lastRoundTripTime)
+        {
+
+        }
+
         /// <summary>
         /// The relative client identifier targeted for the serialization of this <see cref="NetworkBehaviour"/> instance.
         /// </summary>

Runtime/Core/NetworkBehaviourUpdater.cs

@@ -11,6 +11,7 @@ namespace Unity.Netcode
         private NetworkManager m_NetworkManager;
         private NetworkConnectionManager m_ConnectionManager;
         private HashSet<NetworkObject> m_DirtyNetworkObjects = new HashSet<NetworkObject>();
+        private HashSet<NetworkObject> m_PendingDirtyNetworkObjects = new HashSet<NetworkObject>();
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
         private ProfilerMarker m_NetworkBehaviourUpdate = new ProfilerMarker($"{nameof(NetworkBehaviour)}.{nameof(NetworkBehaviourUpdate)}");
@@ -18,7 +19,7 @@ namespace Unity.Netcode
 
         internal void AddForUpdate(NetworkObject networkObject)
         {
-            m_DirtyNetworkObjects.Add(networkObject);
+            m_PendingDirtyNetworkObjects.Add(networkObject);
         }
 
         internal void NetworkBehaviourUpdate()
@@ -28,6 +29,9 @@ namespace Unity.Netcode
 #endif
             try
             {
+                m_DirtyNetworkObjects.UnionWith(m_PendingDirtyNetworkObjects);
+                m_PendingDirtyNetworkObjects.Clear();
+
                 // NetworkObject references can become null, when hidden or despawned. Once NUll, there is no point
                 // trying to process them, even if they were previously marked as dirty.
                 m_DirtyNetworkObjects.RemoveWhere((sobj) => sobj == null);

Runtime/Core/NetworkManager.cs

@@ -8,6 +8,7 @@ using UnityEditor;
 #endif
 using UnityEngine.SceneManagement;
 using Debug = UnityEngine.Debug;
+using Unity.Netcode.Components;
 
 namespace Unity.Netcode
 {
@@ -35,17 +36,13 @@ namespace Unity.Netcode
 
 #pragma warning restore IDE1006 // restore naming rule violation check
 
+        internal static bool IsDistributedAuthority;
+
         /// <summary>
         /// Distributed Authority Mode
         /// Returns true if the current session is running in distributed authority mode.
         /// </summary>
-        public bool DistributedAuthorityMode
+        public bool DistributedAuthorityMode { get; private set; }
-        {
-            get
-            {
-                return NetworkConfig.SessionMode == SessionModeTypes.DistributedAuthority;
-            }
-        }
 
         /// <summary>
         /// Distributed Authority Mode
@@ -130,6 +127,18 @@ namespace Unity.Netcode
 
         public ulong CurrentSessionOwner { get; internal set; }
 
+        /// <summary>
+        /// Delegate declaration for <see cref="OnSessionOwnerPromoted"/>
+        /// </summary>
+        /// <param name="sessionOwnerPromoted">the new session owner client identifier</param>
+        public delegate void OnSessionOwnerPromotedDelegateHandler(ulong sessionOwnerPromoted);
+
+        /// <summary>
+        /// Network Topology: Distributed Authority
+        /// When a new session owner is promoted, this event is triggered on all connected clients
+        /// </summary>
+        public event OnSessionOwnerPromotedDelegateHandler OnSessionOwnerPromoted;
+
         internal void SetSessionOwner(ulong sessionOwner)
         {
             var previousSessionOwner = CurrentSessionOwner;
@@ -150,10 +159,12 @@ namespace Unity.Netcode
                     }
                 }
             }
+
+            OnSessionOwnerPromoted?.Invoke(sessionOwner);
         }
 
         // TODO: Make this internal after testing
-        public void PromoteSessionOwner(ulong clientId)
+        internal void PromoteSessionOwner(ulong clientId)
         {
             if (!DistributedAuthorityMode)
             {
@@ -177,24 +188,112 @@ namespace Unity.Netcode
             }
         }
 
+        internal Dictionary<ulong, NetworkTransform> NetworkTransformUpdate = new Dictionary<ulong, NetworkTransform>();
+#if COM_UNITY_MODULES_PHYSICS
+        internal Dictionary<ulong, NetworkTransform> NetworkTransformFixedUpdate = new Dictionary<ulong, NetworkTransform>();
+#endif
+
+        internal void NetworkTransformRegistration(NetworkTransform networkTransform, bool forUpdate = true, bool register = true)
+        {
+            if (forUpdate)
+            {
+                if (register)
+                {
+                    if (!NetworkTransformUpdate.ContainsKey(networkTransform.NetworkObjectId))
+                    {
+                        NetworkTransformUpdate.Add(networkTransform.NetworkObjectId, networkTransform);
+                    }
+                }
+                else
+                {
+                    NetworkTransformUpdate.Remove(networkTransform.NetworkObjectId);
+                }
+            }
+#if COM_UNITY_MODULES_PHYSICS
+            else
+            {
+                if (register)
+                {
+                    if (!NetworkTransformFixedUpdate.ContainsKey(networkTransform.NetworkObjectId))
+                    {
+                        NetworkTransformFixedUpdate.Add(networkTransform.NetworkObjectId, networkTransform);
+                    }
+                }
+                else
+                {
+                    NetworkTransformFixedUpdate.Remove(networkTransform.NetworkObjectId);
+                }
+            }
+#endif
+        }
+
+        private void UpdateTopology()
+        {
+            var transportTopology = IsListening ? NetworkConfig.NetworkTransport.CurrentTopology() : NetworkConfig.NetworkTopology;
+            if (transportTopology != NetworkConfig.NetworkTopology)
+            {
+                NetworkLog.LogErrorServer($"[Topology Mismatch] Transport detected an issue with the topology ({transportTopology} | {NetworkConfig.NetworkTopology}) usage or setting! Disconnecting from session.");
+                Shutdown();
+            }
+            else
+            {
+                IsDistributedAuthority = DistributedAuthorityMode = transportTopology == NetworkTopologyTypes.DistributedAuthority;
+            }
+        }
+
         public void NetworkUpdate(NetworkUpdateStage updateStage)
         {
             switch (updateStage)
             {
                 case NetworkUpdateStage.EarlyUpdate:
                     {
+                        UpdateTopology();
                         ConnectionManager.ProcessPendingApprovals();
                         ConnectionManager.PollAndHandleNetworkEvents();
 
                         DeferredMessageManager.ProcessTriggers(IDeferredNetworkMessageManager.TriggerType.OnNextFrame, 0);
 
+                        AnticipationSystem.SetupForUpdate();
                         MessageManager.ProcessIncomingMessageQueue();
                         MessageManager.CleanupDisconnectedClients();
+                        AnticipationSystem.ProcessReanticipation();
                     }
                     break;
+#if COM_UNITY_MODULES_PHYSICS
+                case NetworkUpdateStage.FixedUpdate:
+                    {
+                        foreach (var networkTransformEntry in NetworkTransformFixedUpdate)
+                        {
+                            if (networkTransformEntry.Value.gameObject.activeInHierarchy && networkTransformEntry.Value.IsSpawned)
+                            {
+                                networkTransformEntry.Value.OnFixedUpdate();
+                            }
+                        }
+                    }
+                    break;
+#endif
                 case NetworkUpdateStage.PreUpdate:
                     {
                         NetworkTimeSystem.UpdateTime();
+                        AnticipationSystem.Update();
+                    }
+                    break;
+                case NetworkUpdateStage.PreLateUpdate:
+                    {
+                        // Non-physics based non-authority NetworkTransforms update their states after all other components
+                        foreach (var networkTransformEntry in NetworkTransformUpdate)
+                        {
+                            if (networkTransformEntry.Value.gameObject.activeInHierarchy && networkTransformEntry.Value.IsSpawned)
+                            {
+                                networkTransformEntry.Value.OnUpdate();
+                            }
+                        }
+                    }
+                    break;
+                case NetworkUpdateStage.PostScriptLateUpdate:
+                    {
+                        AnticipationSystem.Sync();
+                        AnticipationSystem.SetupForRender();
                     }
                     break;
                 case NetworkUpdateStage.PostLateUpdate:
@@ -436,6 +535,25 @@ namespace Unity.Netcode
             remove => ConnectionManager.OnTransportFailure -= value;
         }
 
+        public delegate void ReanticipateDelegate(double lastRoundTripTime);
+
+        /// <summary>
+        /// This callback is called after all individual OnReanticipate calls on AnticipatedNetworkVariable
+        /// and AnticipatedNetworkTransform values have been invoked. The first parameter is a hash set of
+        /// all the variables that have been changed on this frame (you can detect a particular variable by
+        /// checking if the set contains it), while the second parameter is a set of all anticipated network
+        /// transforms that have been changed. Both are passed as their base class type.
+        ///
+        /// The third parameter is the local time corresponding to the current authoritative server state
+        /// (i.e., to determine the amount of time that needs to be re-simulated, you will use
+        /// NetworkManager.LocalTime.Time - authorityTime).
+        /// </summary>
+        public event ReanticipateDelegate OnReanticipate
+        {
+            add => AnticipationSystem.OnReanticipate += value;
+            remove => AnticipationSystem.OnReanticipate -= value;
+        }
+
         /// <summary>
         /// The callback to invoke during connection approval. Allows client code to decide whether or not to allow incoming client connection
         /// </summary>
@@ -680,6 +798,8 @@ namespace Unity.Netcode
         /// </summary>
         public NetworkTickSystem NetworkTickSystem { get; private set; }
 
+        internal AnticipationSystem AnticipationSystem { get; private set; }
+
         /// <summary>
         /// Used for time mocking in tests
         /// </summary>
@@ -942,6 +1062,12 @@ namespace Unity.Netcode
 
         internal void Initialize(bool server)
         {
+#if COM_UNITY_MODULES_PHYSICS
+            NetworkTransformFixedUpdate.Clear();
+#endif
+            NetworkTransformUpdate.Clear();
+
+            UpdateTopology();
 
             //DANGOEXP TODO: Remove this before finalizing the experimental release
             NetworkConfig.AutoSpawnPlayerPrefabClientSide = DistributedAuthorityMode;
@@ -978,7 +1104,12 @@ namespace Unity.Netcode
             }
 
             this.RegisterNetworkUpdate(NetworkUpdateStage.EarlyUpdate);
+#if COM_UNITY_MODULES_PHYSICS
+            this.RegisterNetworkUpdate(NetworkUpdateStage.FixedUpdate);
+#endif
             this.RegisterNetworkUpdate(NetworkUpdateStage.PreUpdate);
+            this.RegisterNetworkUpdate(NetworkUpdateStage.PostScriptLateUpdate);
+            this.RegisterNetworkUpdate(NetworkUpdateStage.PreLateUpdate);
             this.RegisterNetworkUpdate(NetworkUpdateStage.PostLateUpdate);
 
             // ComponentFactory needs to set its defaults next
@@ -994,11 +1125,17 @@ namespace Unity.Netcode
                 MessageManager.Hook(new NetworkManagerHooks(this));
 
 #if DEVELOPMENT_BUILD || UNITY_EDITOR
-                MessageManager.Hook(new ProfilingHooks());
+                if (NetworkConfig.NetworkProfilingMetrics)
+                {
+                    MessageManager.Hook(new ProfilingHooks());
+                }
 #endif
 
 #if MULTIPLAYER_TOOLS
-                MessageManager.Hook(new MetricHooks(this));
+                if (NetworkConfig.NetworkMessageMetrics)
+                {
+                    MessageManager.Hook(new MetricHooks(this));
+                }
 #endif
 
                 // Assures there is a server message queue available
@@ -1011,6 +1148,7 @@ namespace Unity.Netcode
             // The remaining systems can then be initialized
             NetworkTimeSystem = server ? NetworkTimeSystem.ServerTimeSystem() : new NetworkTimeSystem(1.0 / NetworkConfig.TickRate);
             NetworkTickSystem = NetworkTimeSystem.Initialize(this);
+            AnticipationSystem = new AnticipationSystem(this);
 
             // Create spawn manager instance
             SpawnManager = new NetworkSpawnManager(this);
@@ -1112,6 +1250,17 @@ namespace Unity.Netcode
                 {
                     SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
 
+                    // Notify the server that all in-scnee placed NetworkObjects are spawned at this time.
+                    foreach (var networkObject in SpawnManager.SpawnedObjectsList)
+                    {
+                        networkObject.InternalInSceneNetworkObjectsSpawned();
+                    }
+
+                    // Notify the server that everything should be synchronized/spawned at this time.
+                    foreach (var networkObject in SpawnManager.SpawnedObjectsList)
+                    {
+                        networkObject.InternalNetworkSessionSynchronized();
+                    }
                     OnServerStarted?.Invoke();
                     ConnectionManager.LocalClient.IsApproved = true;
                     return true;
@@ -1258,6 +1407,17 @@ namespace Unity.Netcode
             }
 
             SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
+            // Notify the host that all in-scnee placed NetworkObjects are spawned at this time.
+            foreach (var networkObject in SpawnManager.SpawnedObjectsList)
+            {
+                networkObject.InternalInSceneNetworkObjectsSpawned();
+            }
+
+            // Notify the host that everything should be synchronized/spawned at this time.
+            foreach (var networkObject in SpawnManager.SpawnedObjectsList)
+            {
+                networkObject.InternalNetworkSessionSynchronized();
+            }
 
             OnServerStarted?.Invoke();
             OnClientStarted?.Invoke();

Runtime/Core/NetworkObject.cs

@@ -2,6 +2,7 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Runtime.CompilerServices;
+using Unity.Netcode.Components;
 #if UNITY_EDITOR
 using UnityEditor;
 #if UNITY_2021_2_OR_NEWER
@@ -14,6 +15,7 @@ using UnityEngine;
 using UnityEngine.SceneManagement;
 
 
+
 namespace Unity.Netcode
 {
     /// <summary>
@@ -55,6 +57,34 @@ namespace Unity.Netcode
             }
         }
 
+        /// <summary>
+        /// All <see cref="NetworkTransform"></see> component instances associated with a <see cref="NetworkObject"/> component instance.
+        /// </summary>
+        /// <remarks>
+        /// When parented, all child <see cref="NetworkTransform"/> component instances under a <see cref="NetworkObject"/> component instance that do not have
+        /// another <see cref="NetworkObject"/> component instance will be associated with the initial component instance. This list does not contain any parented
+        /// children <see cref="NetworkObject"/> instances with one or more <see cref="NetworkTransform"/> component instance(s).
+        /// </remarks>
+        public List<NetworkTransform> NetworkTransforms { get; private set; }
+
+#if COM_UNITY_MODULES_PHYSICS
+        /// <summary>
+        /// All <see cref="NetworkRigidbodyBase"></see> component instances associated with a <see cref="NetworkObject"/> component instance.
+        /// NOTE: This is only available if a physics package is included. If not, then this will not be available!
+        /// </summary>
+        /// <remarks>
+        /// When parented, all child <see cref="NetworkRigidbodyBase"/> component instances under a <see cref="NetworkObject"/> component instance that do not have
+        /// another <see cref="NetworkObject"/> component instance will be associated with the initial component instance. This list does not contain any parented
+        /// child <see cref="NetworkObject"/> instances with one or more <see cref="NetworkTransform"/> component instance(s).
+        /// </remarks>
+        public List<NetworkRigidbodyBase> NetworkRigidbodies { get; private set; }
+#endif
+        /// <summary>
+        /// The current parent <see cref="NetworkObject"/> component instance to this <see cref="NetworkObject"/> component instance. When there is no parent then
+        /// this will be <see cref="null"/>.
+        /// </summary>
+        public NetworkObject CurrentParent { get; private set; }
+
 #if UNITY_EDITOR
         private const string k_GlobalIdTemplate = "GlobalObjectId_V1-{0}-{1}-{2}-{3}";
 
@@ -398,8 +428,11 @@ namespace Unity.Netcode
 
         /// <summary>
         /// Determines whether a NetworkObject can be distributed to other clients during
-        /// a <see cref="SessionModeTypes.DistributedAuthority"/> session.
+        /// a <see cref="NetworkTopologyTypes.DistributedAuthority"/> session.
         /// </summary>
+#if !MULTIPLAYER_SERVICES_SDK_INSTALLED
+        [HideInInspector]
+#endif
         [SerializeField]
         internal OwnershipStatus Ownership = OwnershipStatus.Distributable;
 
@@ -1894,7 +1927,6 @@ namespace Unity.Netcode
 
         internal bool InternalTrySetParent(NetworkObject parent, bool worldPositionStays = true)
         {
-
             if (parent != null && (IsSpawned ^ parent.IsSpawned))
             {
                 if (NetworkManager != null && !NetworkManager.ShutdownInProgress)
@@ -1907,10 +1939,12 @@ namespace Unity.Netcode
 
             if (parent == null)
             {
+                CurrentParent = null;
                 transform.SetParent(null, worldPositionStays);
             }
             else
             {
+                CurrentParent = parent;
                 transform.SetParent(parent.transform, worldPositionStays);
             }
 
@@ -2209,6 +2243,18 @@ namespace Unity.Netcode
             }
         }
 
+        internal void InvokeBehaviourNetworkPreSpawn()
+        {
+            var networkManager = NetworkManager;
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                if (ChildNetworkBehaviours[i].gameObject.activeInHierarchy)
+                {
+                    ChildNetworkBehaviours[i].NetworkPreSpawn(ref networkManager);
+                }
+            }
+        }
+
         internal void InvokeBehaviourNetworkSpawn()
         {
             NetworkManager.SpawnManager.UpdateOwnershipTable(this, OwnerClientId);
@@ -2238,6 +2284,42 @@ namespace Unity.Netcode
             }
         }
 
+        internal void InvokeBehaviourNetworkPostSpawn()
+        {
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                if (ChildNetworkBehaviours[i].gameObject.activeInHierarchy)
+                {
+                    ChildNetworkBehaviours[i].NetworkPostSpawn();
+                }
+            }
+        }
+
+
+        internal void InternalNetworkSessionSynchronized()
+        {
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                if (ChildNetworkBehaviours[i].gameObject.activeInHierarchy)
+                {
+                    ChildNetworkBehaviours[i].NetworkSessionSynchronized();
+                }
+            }
+        }
+
+        internal void InternalInSceneNetworkObjectsSpawned()
+        {
+            for (int i = 0; i < ChildNetworkBehaviours.Count; i++)
+            {
+                if (ChildNetworkBehaviours[i].gameObject.activeInHierarchy)
+                {
+                    ChildNetworkBehaviours[i].InSceneNetworkObjectsSpawned();
+                }
+            }
+        }
+
+
+
         internal void InvokeBehaviourNetworkDespawn()
         {
             NetworkManager.SpawnManager.UpdateOwnershipTable(this, OwnerClientId, true);
@@ -2271,6 +2353,25 @@ namespace Unity.Netcode
                     if (networkBehaviours[i].NetworkObject == this)
                     {
                         m_ChildNetworkBehaviours.Add(networkBehaviours[i]);
+                        var type = networkBehaviours[i].GetType();
+                        if (type.IsInstanceOfType(typeof(NetworkTransform)) || type.IsSubclassOf(typeof(NetworkTransform)))
+                        {
+                            if (NetworkTransforms == null)
+                            {
+                                NetworkTransforms = new List<NetworkTransform>();
+                            }
+                            NetworkTransforms.Add(networkBehaviours[i] as NetworkTransform);
+                        }
+#if COM_UNITY_MODULES_PHYSICS
+                        else if (type.IsSubclassOf(typeof(NetworkRigidbodyBase)))
+                        {
+                            if (NetworkRigidbodies == null)
+                            {
+                                NetworkRigidbodies = new List<NetworkRigidbodyBase>();
+                            }
+                            NetworkRigidbodies.Add(networkBehaviours[i] as NetworkRigidbodyBase);
+                        }
+#endif
                     }
                 }
 
@@ -2862,6 +2963,9 @@ namespace Unity.Netcode
             // in order to be able to determine which NetworkVariables the client will be allowed to read.
             networkObject.OwnerClientId = sceneObject.OwnerClientId;
 
+            // Special Case: Invoke NetworkBehaviour.OnPreSpawn methods here before SynchronizeNetworkBehaviours
+            networkObject.InvokeBehaviourNetworkPreSpawn();
+
             // Synchronize NetworkBehaviours
             var bufferSerializer = new BufferSerializer<BufferSerializerReader>(new BufferSerializerReader(reader));
             networkObject.SynchronizeNetworkBehaviours(ref bufferSerializer, networkManager.LocalClientId);
@@ -3051,6 +3155,11 @@ namespace Unity.Netcode
 
         private void Awake()
         {
+            m_ChildNetworkBehaviours = null;
+            NetworkTransforms?.Clear();
+#if COM_UNITY_MODULES_PHYSICS
+            NetworkRigidbodies?.Clear();
+#endif
             SetCachedParent(transform.parent);
             SceneOrigin = gameObject.scene;
         }

Runtime/Core/NetworkUpdateLoop.cs

@@ -54,6 +54,12 @@ namespace Unity.Netcode
         /// </summary>
         PreLateUpdate = 6,
         /// <summary>
+        /// Updated after Monobehaviour.LateUpdate, but BEFORE rendering
+        /// </summary>
+        // Yes, these numbers are out of order due to backward compatibility requirements.
+        // The enum values are listed in the order they will be called.
+        PostScriptLateUpdate = 8,
+        /// <summary>
         /// Updated after the Monobehaviour.LateUpdate for all components is invoked
         /// </summary>
         PostLateUpdate = 7
@@ -258,6 +264,18 @@ namespace Unity.Netcode
             }
         }
 
+        internal struct NetworkPostScriptLateUpdate
+        {
+            public static PlayerLoopSystem CreateLoopSystem()
+            {
+                return new PlayerLoopSystem
+                {
+                    type = typeof(NetworkPostScriptLateUpdate),
+                    updateDelegate = () => RunNetworkUpdateStage(NetworkUpdateStage.PostScriptLateUpdate)
+                };
+            }
+        }
+
         internal struct NetworkPostLateUpdate
         {
             public static PlayerLoopSystem CreateLoopSystem()
@@ -399,6 +417,7 @@ namespace Unity.Netcode
                 else if (currentSystem.type == typeof(PreLateUpdate))
                 {
                     TryAddLoopSystem(ref currentSystem, NetworkPreLateUpdate.CreateLoopSystem(), typeof(PreLateUpdate.ScriptRunBehaviourLateUpdate), LoopSystemPosition.Before);
+                    TryAddLoopSystem(ref currentSystem, NetworkPostScriptLateUpdate.CreateLoopSystem(), typeof(PreLateUpdate.ScriptRunBehaviourLateUpdate), LoopSystemPosition.After);
                 }
                 else if (currentSystem.type == typeof(PostLateUpdate))
                 {
@@ -440,6 +459,7 @@ namespace Unity.Netcode
                 else if (currentSystem.type == typeof(PreLateUpdate))
                 {
                     TryRemoveLoopSystem(ref currentSystem, typeof(NetworkPreLateUpdate));
+                    TryRemoveLoopSystem(ref currentSystem, typeof(NetworkPostScriptLateUpdate));
                 }
                 else if (currentSystem.type == typeof(PostLateUpdate))
                 {

Runtime/Messaging/CustomMessageManager.cs

@@ -63,16 +63,39 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendUnnamedMessage(IReadOnlyList<ulong> clientIds, FastBufferWriter messageBuffer, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
-            if (!m_NetworkManager.IsServer)
-            {
-                throw new InvalidOperationException("Can not send unnamed messages to multiple users as a client");
-            }
-
             if (clientIds == null)
             {
-                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List");
+                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List!");
             }
 
+            if (!m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.IsServer)
+            {
+                if (clientIds.Count > 1 || (clientIds.Count == 1 && clientIds[0] != NetworkManager.ServerClientId))
+                {
+                    Debug.LogError("Clients cannot send unnamed messages to other clients!");
+                    return;
+                }
+                else if (clientIds.Count == 1)
+                {
+                    SendUnnamedMessage(clientIds[0], messageBuffer, networkDelivery);
+                }
+            }
+            else if (m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.DAHost)
+            {
+                if (clientIds.Count > 1)
+                {
+                    Debug.LogError("Sending an unnamed message to multiple clients is not yet supported in distributed authority.");
+                    return;
+                }
+            }
+
+            if (clientIds.Count == 0)
+            {
+                Debug.LogError($"{nameof(clientIds)} is empty! No clients to send to.");
+                return;
+            }
+
+
             if (m_NetworkManager.IsHost)
             {
                 for (var i = 0; i < clientIds.Count; ++i)
@@ -203,6 +226,14 @@ namespace Unity.Netcode
             var hash32 = XXHash.Hash32(name);
             var hash64 = XXHash.Hash64(name);
 
+            if (m_NetworkManager.LogLevel <= LogLevel.Developer)
+            {
+                if (m_MessageHandlerNameLookup32.ContainsKey(hash32) || m_MessageHandlerNameLookup64.ContainsKey(hash64))
+                {
+                    Debug.LogWarning($"Registering {name} named message over existing registration! Your previous registration's callback is being overwritten!");
+                }
+            }
+
             m_NamedMessageHandlers32[hash32] = callback;
             m_NamedMessageHandlers64[hash64] = callback;
 
@@ -303,14 +334,37 @@ namespace Unity.Netcode
         /// <param name="networkDelivery">The delivery type (QoS) to send data with</param>
         public void SendNamedMessage(string messageName, IReadOnlyList<ulong> clientIds, FastBufferWriter messageStream, NetworkDelivery networkDelivery = NetworkDelivery.ReliableSequenced)
         {
-            if (!m_NetworkManager.IsServer)
-            {
-                throw new InvalidOperationException("Can not send unnamed messages to multiple users as a client");
-            }
-
             if (clientIds == null)
             {
-                throw new ArgumentNullException(nameof(clientIds), "You must pass in a valid clientId List");
+                throw new ArgumentNullException(nameof(clientIds), "Client list is null! You must pass in a valid clientId list to send a named message.");
+            }
+
+            if (!m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.IsServer)
+            {
+                if (clientIds.Count > 1 || (clientIds.Count == 1 && clientIds[0] != NetworkManager.ServerClientId))
+                {
+                    Debug.LogError("Clients cannot send named messages to other clients!");
+                    return;
+                }
+                else if (clientIds.Count == 1)
+                {
+                    SendNamedMessage(messageName, clientIds[0], messageStream, networkDelivery);
+                    return;
+                }
+            }
+            else if (m_NetworkManager.DistributedAuthorityMode && !m_NetworkManager.DAHost)
+            {
+                if (clientIds.Count > 1)
+                {
+                    Debug.LogError("Sending a named message to multiple clients is not yet supported in distributed authority.");
+                    return;
+                }
+            }
+
+            if (clientIds.Count == 0)
+            {
+                Debug.LogError($"{nameof(clientIds)} is empty! No clients to send the named message {messageName} to!");
+                return;
             }
 
             ulong hash = 0;

Runtime/Messaging/ILPPMessageProvider.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Collections.Generic;
 #if UNITY_EDITOR
 using UnityEditor;
@@ -12,9 +13,121 @@ namespace Unity.Netcode
         internal static readonly List<NetworkMessageManager.MessageWithHandler> __network_message_types = new List<NetworkMessageManager.MessageWithHandler>();
 #pragma warning restore IDE1006 // restore naming rule violation check
 
+        /// <summary>
+        /// Enum representing the different types of messages that can be sent over the network.
+        /// The values cannot be changed, as they are used to serialize and deserialize messages.
+        /// Adding new messages should be done by adding new values to the end of the enum 
+        /// using the next free value.
+        /// </summary>
+        /// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        /// Add any new Message types to this table at the END with incremented index value
+        /// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+        internal enum NetworkMessageTypes : uint
+        {
+            ConnectionApproved = 0,
+            ConnectionRequest = 1,
+            ChangeOwnership = 2,
+            ClientConnected = 3,
+            ClientDisconnected = 4,
+            ClientRpc = 5,
+            CreateObject = 6,
+            DestroyObject = 7,
+            DisconnectReason = 8,
+            ForwardClientRpc = 9,
+            ForwardServerRpc = 10,
+            NamedMessage = 11,
+            NetworkTransformMessage = 12,
+            NetworkVariableDelta = 13,
+            ParentSync = 14,
+            Proxy = 15,
+            Rpc = 16,
+            SceneEvent = 17,
+            ServerLog = 18,
+            ServerRpc = 19,
+            SessionOwner = 20,
+            TimeSync = 21,
+            Unnamed = 22,
+            AnticipationCounterSyncPingMessage = 23,
+            AnticipationCounterSyncPongMessage = 24,
+        }
+
+
+        // Enable this for integration tests that need no message types defined
+        internal static bool IntegrationTestNoMessages;
+
         public List<NetworkMessageManager.MessageWithHandler> GetMessages()
         {
-            return __network_message_types;
+            // return no message types when defined for integration tests
+            if (IntegrationTestNoMessages)
+            {
+                return new List<NetworkMessageManager.MessageWithHandler>();
+            }
+            var messageTypeCount = Enum.GetValues(typeof(NetworkMessageTypes)).Length;
+            // Assure the allowed types count is the same as our NetworkMessageType enum count
+            if (__network_message_types.Count != messageTypeCount)
+            {
+                throw new Exception($"Allowed types is not equal to the number of message type indices! Allowed Count: {__network_message_types.Count} | Index Count: {messageTypeCount}");
+            }
+
+            // Populate with blanks to be replaced later
+            var adjustedMessageTypes = new List<NetworkMessageManager.MessageWithHandler>();
+            var blank = new NetworkMessageManager.MessageWithHandler();
+            for (int i = 0; i < messageTypeCount; i++)
+            {
+                adjustedMessageTypes.Add(blank);
+            }
+
+            // Create a type to enum index lookup table
+            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+            // Add new Message types to this table paired with its new NetworkMessageTypes enum
+            // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+            var messageTypes = new Dictionary<Type, NetworkMessageTypes>
+            {
+                { typeof(ConnectionApprovedMessage), NetworkMessageTypes.ConnectionApproved }, // This MUST be first
+                { typeof(ConnectionRequestMessage), NetworkMessageTypes.ConnectionRequest }, // This MUST be second
+                { typeof(ChangeOwnershipMessage), NetworkMessageTypes.ChangeOwnership },
+                { typeof(ClientConnectedMessage), NetworkMessageTypes.ClientConnected },
+                { typeof(ClientDisconnectedMessage), NetworkMessageTypes.ClientDisconnected },
+                { typeof(ClientRpcMessage), NetworkMessageTypes.ClientRpc },
+                { typeof(CreateObjectMessage), NetworkMessageTypes.CreateObject },
+                { typeof(DestroyObjectMessage), NetworkMessageTypes.DestroyObject },
+                { typeof(DisconnectReasonMessage), NetworkMessageTypes.DisconnectReason },
+                { typeof(ForwardClientRpcMessage), NetworkMessageTypes.ForwardClientRpc },
+                { typeof(ForwardServerRpcMessage), NetworkMessageTypes.ForwardServerRpc },
+                { typeof(NamedMessage), NetworkMessageTypes.NamedMessage },
+                { typeof(NetworkTransformMessage), NetworkMessageTypes.NetworkTransformMessage },
+                { typeof(NetworkVariableDeltaMessage), NetworkMessageTypes.NetworkVariableDelta },
+                { typeof(ParentSyncMessage), NetworkMessageTypes.ParentSync },
+                { typeof(ProxyMessage), NetworkMessageTypes.Proxy },
+                { typeof(RpcMessage), NetworkMessageTypes.Rpc },
+                { typeof(SceneEventMessage), NetworkMessageTypes.SceneEvent },
+                { typeof(ServerLogMessage), NetworkMessageTypes.ServerLog },
+                { typeof(ServerRpcMessage), NetworkMessageTypes.ServerRpc },
+                { typeof(TimeSyncMessage), NetworkMessageTypes.TimeSync },
+                { typeof(UnnamedMessage), NetworkMessageTypes.Unnamed },
+                { typeof(SessionOwnerMessage), NetworkMessageTypes.SessionOwner },
+                { typeof(AnticipationCounterSyncPingMessage), NetworkMessageTypes.AnticipationCounterSyncPingMessage},
+                { typeof(AnticipationCounterSyncPongMessage), NetworkMessageTypes.AnticipationCounterSyncPongMessage},
+            };
+
+            // Assure the type to lookup table count and NetworkMessageType enum count matches (i.e. to catch human error when adding new messages)
+            if (messageTypes.Count != messageTypeCount)
+            {
+                throw new Exception($"Message type to Message type index count mistmatch! Table Count: {messageTypes.Count} | Index Count: {messageTypeCount}");
+            }
+
+            // Now order the allowed types list based on the order of the NetworkMessageType enum
+            foreach (var messageHandler in __network_message_types)
+            {
+                if (!messageTypes.ContainsKey(messageHandler.MessageType))
+                {
+                    throw new Exception($"Missing message type from lookup table: {messageHandler.MessageType}");
+                }
+                adjustedMessageTypes[(int)messageTypes[messageHandler.MessageType]] = messageHandler;
+            }
+
+            // return the NetworkMessageType enum ordered list
+            return adjustedMessageTypes;
         }
 
 #if UNITY_EDITOR

Runtime/Messaging/Messages/AnticipationCounterSyncPingMessage.cs

@@ -0,0 +1,70 @@
+namespace Unity.Netcode
+{
+    internal struct AnticipationCounterSyncPingMessage : INetworkMessage
+    {
+        public int Version => 0;
+
+        public ulong Counter;
+        public double Time;
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            BytePacker.WriteValuePacked(writer, Counter);
+            writer.WriteValueSafe(Time);
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (!networkManager.IsServer)
+            {
+                return false;
+            }
+            ByteUnpacker.ReadValuePacked(reader, out Counter);
+            reader.ReadValueSafe(out Time);
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (networkManager.IsListening && !networkManager.ShutdownInProgress && networkManager.ConnectedClients.ContainsKey(context.SenderId))
+            {
+                var message = new AnticipationCounterSyncPongMessage { Counter = Counter, Time = Time };
+                networkManager.MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, context.SenderId);
+            }
+        }
+    }
+    internal struct AnticipationCounterSyncPongMessage : INetworkMessage
+    {
+        public int Version => 0;
+
+        public ulong Counter;
+        public double Time;
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            BytePacker.WriteValuePacked(writer, Counter);
+            writer.WriteValueSafe(Time);
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            if (!networkManager.IsClient)
+            {
+                return false;
+            }
+            ByteUnpacker.ReadValuePacked(reader, out Counter);
+            reader.ReadValueSafe(out Time);
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var networkManager = (NetworkManager)context.SystemOwner;
+            networkManager.AnticipationSystem.LastAnticipationAck = Counter;
+            networkManager.AnticipationSystem.LastAnticipationAckTime = Time;
+        }
+    }
+}

Runtime/Messaging/Messages/AnticipationCounterSyncPingMessage.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: b7d5c92979ad7e646a078aaf058b53a9

Runtime/Messaging/Messages/ChangeOwnershipMessage.cs

@@ -5,6 +5,8 @@ namespace Unity.Netcode
     {
         public int Version => 0;
 
+        private const string k_Name = "ChangeOwnershipMessage";
+
         public ulong NetworkObjectId;
         public ulong OwnerClientId;
         // DANGOEXP TODO: Remove these notes or change their format
@@ -199,7 +201,7 @@ namespace Unity.Netcode
             // authority of the NetworkObject in question.
             if (!networkManager.DAHost && !networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, k_Name);
                 return false;
             }
             return true;

Runtime/Messaging/Messages/ConnectionApprovedMessage.cs

@@ -222,6 +222,12 @@ namespace Unity.Netcode
                 }
                 // When scene management is disabled we notify after everything is synchronized
                 networkManager.ConnectionManager.InvokeOnClientConnectedCallback(context.SenderId);
+
+                // For convenience, notify all NetworkBehaviours that synchronization is complete.
+                foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
+                {
+                    networkObject.InternalNetworkSessionSynchronized();
+                }
             }
             else
             {
@@ -230,16 +236,40 @@ namespace Unity.Netcode
                     // Mark the client being connected
                     networkManager.IsConnectedClient = true;
 
-                    // Spawn any in-scene placed NetworkObjects
+                    networkManager.SceneManager.IsRestoringSession = IsRestoredSession;
-                    networkManager.SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
 
-                    // Spawn the local player of the session owner
+                    if (!IsRestoredSession)
-                    if (networkManager.AutoSpawnPlayerPrefabClientSide)
                     {
-                        networkManager.ConnectionManager.CreateAndSpawnPlayer(OwnerClientId);
+                        // Spawn any in-scene placed NetworkObjects
+                        networkManager.SpawnManager.ServerSpawnSceneObjectsOnStartSweep();
+
+                        // With scene management enabled and since the session owner doesn't send a Synchronize scene event synchronize itself,
+                        // we need to notify the session owner that all in-scnee placed NetworkObjects are spawned at this time.
+                        foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
+                        {
+                            networkObject.InternalInSceneNetworkObjectsSpawned();
+                        }
+
+                        // Spawn the local player of the session owner
+                        if (networkManager.AutoSpawnPlayerPrefabClientSide)
+                        {
+                            networkManager.ConnectionManager.CreateAndSpawnPlayer(OwnerClientId);
+                        }
+
+                        // Synchronize the service with the initial session owner's loaded scenes and spawned objects
+                        networkManager.SceneManager.SynchronizeNetworkObjects(NetworkManager.ServerClientId);
+
+                        // With scene management enabled and since the session owner doesn't send a Synchronize scene event synchronize itself,
+                        // we need to notify the session owner that everything should be synchronized/spawned at this time.
+                        foreach (var networkObject in networkManager.SpawnManager.SpawnedObjectsList)
+                        {
+                            networkObject.InternalNetworkSessionSynchronized();
+                        }
+
+                        // When scene management is enabled and since the session owner is synchronizing the service (i.e. acting like  host),
+                        // we need to locallyh invoke the OnClientConnected callback at this point in time.
+                        networkManager.ConnectionManager.InvokeOnClientConnectedCallback(OwnerClientId);
                     }
-                    // Synchronize the service with the initial session owner's loaded scenes and spawned objects
-                    networkManager.SceneManager.SynchronizeNetworkObjects(NetworkManager.ServerClientId);
                 }
             }
             ConnectedClientIds.Dispose();

Runtime/Messaging/Messages/CreateObjectMessage.cs

@@ -7,6 +7,8 @@ namespace Unity.Netcode
     {
         public int Version => 0;
 
+        private const string k_Name = "CreateObjectMessage";
+
         public NetworkObject.SceneObject ObjectInfo;
         private FastBufferReader m_ReceivedNetworkVariableData;
 
@@ -161,7 +163,7 @@ namespace Unity.Netcode
 
             if (!networkManager.NetworkConfig.ForceSamePrefabs && !networkManager.SpawnManager.HasPrefab(ObjectInfo))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context, GetType().Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnAddPrefab, ObjectInfo.Hash, reader, ref context, k_Name);
                 return false;
             }
             m_ReceivedNetworkVariableData = reader;

Runtime/Messaging/Messages/DestroyObjectMessage.cs

@@ -6,6 +6,8 @@ namespace Unity.Netcode
     {
         public int Version => 0;
 
+        private const string k_Name = "DestroyObjectMessage";
+
         public ulong NetworkObjectId;
         public bool DestroyGameObject;
         private byte m_DestroyFlags;
@@ -84,7 +86,7 @@ namespace Unity.Netcode
                 // Client-Server mode we always defer where in distributed authority mode we only defer if it is not a targeted destroy
                 if (!networkManager.DistributedAuthorityMode || (networkManager.DistributedAuthorityMode && !IsTargetedDestroy))
                 {
-                    networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
+                    networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, k_Name);
                 }
             }
             return true;

Runtime/Messaging/Messages/NetworkTransformMessage.cs

@@ -0,0 +1,193 @@
+using Unity.Netcode.Components;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// NetworkTransform State Update Message
+    /// </summary>
+    internal struct NetworkTransformMessage : INetworkMessage
+    {
+        public int Version => 0;
+        private const string k_Name = "NetworkTransformMessage";
+
+        internal NetworkTransform NetworkTransform;
+
+        // Only used for DAHost
+        internal NetworkTransform.NetworkTransformState State;
+        private FastBufferReader m_CurrentReader;
+
+        internal int BytesWritten;
+
+        private unsafe void CopyPayload(ref FastBufferWriter writer)
+        {
+            writer.WriteBytesSafe(m_CurrentReader.GetUnsafePtrAtCurrentPosition(), m_CurrentReader.Length - m_CurrentReader.Position);
+        }
+
+        public void Serialize(FastBufferWriter writer, int targetVersion)
+        {
+            if (m_CurrentReader.IsInitialized)
+            {
+                CopyPayload(ref writer);
+            }
+            else
+            {
+                BytesWritten = NetworkTransform.SerializeMessage(writer, targetVersion);
+            }
+        }
+
+        public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
+        {
+            var networkManager = context.SystemOwner as NetworkManager;
+            if (networkManager == null)
+            {
+                Debug.LogError($"[{nameof(NetworkTransformMessage)}] System owner context was not of type {nameof(NetworkManager)}!");
+                return false;
+            }
+            var currentPosition = reader.Position;
+            var networkObjectId = (ulong)0;
+            var networkBehaviourId = 0;
+
+            ByteUnpacker.ReadValueBitPacked(reader, out networkObjectId);
+            var isSpawnedLocally = networkManager.SpawnManager.SpawnedObjects.ContainsKey(networkObjectId);
+
+            // Only defer if the NetworkObject is not spawned yet and the local NetworkManager is not running as a DAHost.
+            if (!isSpawnedLocally && !networkManager.DAHost)
+            {
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, networkObjectId, reader, ref context, k_Name);
+                return false;
+            }
+
+            // While the below check and assignment might seem out of place, this is specific to running in DAHost mode when a NetworkObject is
+            // hidden from the DAHost but is visible to other clients. Since the DAHost needs to forward updates to the clients, we ignore processing
+            // this message locally
+            var networkObject = (NetworkObject)null;
+            var isServerAuthoritative = false;
+            var ownerAuthoritativeServerSide = false;
+
+            // Get the behaviour index
+            ByteUnpacker.ReadValueBitPacked(reader, out networkBehaviourId);
+
+            if (isSpawnedLocally)
+            {
+                networkObject = networkManager.SpawnManager.SpawnedObjects[networkObjectId];
+                // Get the target NetworkTransform
+                NetworkTransform = networkObject.ChildNetworkBehaviours[networkBehaviourId] as NetworkTransform;
+                isServerAuthoritative = NetworkTransform.IsServerAuthoritative();
+                ownerAuthoritativeServerSide = !isServerAuthoritative && networkManager.IsServer;
+
+                reader.ReadNetworkSerializableInPlace(ref NetworkTransform.InboundState);
+                NetworkTransform.InboundState.LastSerializedSize = reader.Position - currentPosition;
+            }
+            else
+            {
+                // Deserialize the state
+                reader.ReadNetworkSerializableInPlace(ref State);
+            }
+
+            unsafe
+            {
+                if (ownerAuthoritativeServerSide)
+                {
+                    var targetCount = 1;
+
+                    if (networkManager.DistributedAuthorityMode && networkManager.DAHost)
+                    {
+                        ByteUnpacker.ReadValueBitPacked(reader, out targetCount);
+                    }
+
+                    var targetIds = stackalloc ulong[targetCount];
+
+                    if (networkManager.DistributedAuthorityMode && networkManager.DAHost)
+                    {
+                        var targetId = (ulong)0;
+                        for (int i = 0; i < targetCount; i++)
+                        {
+                            ByteUnpacker.ReadValueBitPacked(reader, out targetId);
+                            targetIds[i] = targetId;
+                        }
+
+                        if (!isSpawnedLocally)
+                        {
+                            // If we are the DAHost and the NetworkObject is hidden from the host we still need to forward this message
+                            ownerAuthoritativeServerSide = networkManager.DAHost && !isSpawnedLocally;
+                        }
+                    }
+
+                    var ownerClientId = (ulong)0;
+
+                    if (networkObject != null)
+                    {
+                        ownerClientId = networkObject.OwnerClientId;
+                        if (ownerClientId == NetworkManager.ServerClientId)
+                        {
+                            // Ownership must have changed, ignore any additional pending messages that might have
+                            // come from a previous owner client.
+                            return true;
+                        }
+                    }
+                    else if (networkManager.DAHost)
+                    {
+                        // Specific to distributed authority mode, the only sender of state updates will be the owner 
+                        ownerClientId = context.SenderId;
+                    }
+
+                    var networkDelivery = State.IsReliableStateUpdate() ? NetworkDelivery.ReliableSequenced : NetworkDelivery.UnreliableSequenced;
+
+                    // Forward the state update if there are any remote clients to foward it to
+                    if (networkManager.ConnectionManager.ConnectedClientsList.Count > (networkManager.IsHost ? 2 : 1))
+                    {
+                        var clientCount = networkManager.DistributedAuthorityMode ? targetCount : networkManager.ConnectionManager.ConnectedClientsList.Count;
+                        if (clientCount == 0)
+                        {
+                            return true;
+                        }
+
+                        // This is only to copy the existing and already serialized struct for forwarding purposes only.
+                        // This will not include any changes made to this struct at this particular stage of processing the message.
+                        var currentMessage = this;
+                        // Create a new reader that replicates this message
+                        currentMessage.m_CurrentReader = new FastBufferReader(reader, Collections.Allocator.None);
+                        // Rewind the new reader to the beginning of the message's payload
+                        currentMessage.m_CurrentReader.Seek(currentPosition);
+                        // Forward the message to all connected clients that are observers of the associated NetworkObject
+
+                        for (int i = 0; i < clientCount; i++)
+                        {
+                            var clientId = networkManager.DistributedAuthorityMode ? targetIds[i] : networkManager.ConnectionManager.ConnectedClientsList[i].ClientId;
+                            if (NetworkManager.ServerClientId == clientId || (!isServerAuthoritative && clientId == ownerClientId) ||
+                                (!networkManager.DistributedAuthorityMode && !networkObject.Observers.Contains(clientId)))
+                            {
+                                continue;
+                            }
+
+                            networkManager.MessageManager.SendMessage(ref currentMessage, networkDelivery, clientId);
+                        }
+                        // Dispose of the reader used for forwarding
+                        currentMessage.m_CurrentReader.Dispose();
+                    }
+                }
+            }
+            return true;
+        }
+
+        public void Handle(ref NetworkContext context)
+        {
+            var networkManager = context.SystemOwner as NetworkManager;
+            // Only if the local NetworkManager instance is running as the DAHost we just exit if there is no local
+            // NetworkTransform component to apply the state update to (i.e. it is hidden from the DAHost and it
+            // just forwarded the state update to any other connected client)
+            if (networkManager.DAHost && NetworkTransform == null)
+            {
+                return;
+            }
+
+            if (NetworkTransform == null)
+            {
+                Debug.LogError($"[{nameof(NetworkTransformMessage)}][Dropped] Reciever {nameof(NetworkTransform)} was not set!");
+                return;
+            }
+            NetworkTransform.TransformStateUpdate(context.SenderId);
+        }
+    }
+}

Runtime/Messaging/Messages/NetworkVariableDeltaMessage.cs

@@ -23,6 +23,8 @@ namespace Unity.Netcode
 
         private FastBufferReader m_ReceivedNetworkVariableData;
 
+        private const string k_Name = "NetworkVariableDeltaMessage";
+
         // DANGO-TODO: Made some modifications here that overlap/won't play nice with EnsureNetworkVariableLenghtSafety.
         // Worth either merging or more cleanly separating these codepaths.
         public void Serialize(FastBufferWriter writer, int targetVersion)
@@ -67,7 +69,8 @@ namespace Unity.Netcode
                 var networkVariable = NetworkBehaviour.NetworkVariableFields[i];
                 var shouldWrite = networkVariable.IsDirty() &&
                     networkVariable.CanClientRead(TargetClientId) &&
-                    (networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId));
+                    (networkManager.IsServer || networkVariable.CanClientWrite(networkManager.LocalClientId)) &&
+                    networkVariable.CanSend();
 
                 // Prevent the server from writing to the client that owns a given NetworkVariable
                 // Allowing the write would send an old value to the client and cause jitter
@@ -296,7 +299,7 @@ namespace Unity.Netcode
                 // DANGO-TODO: Fix me!
                 // When a client-spawned NetworkObject is despawned by the owner client, the owner client will still get messages for deltas and cause this to
                 // log a warning. The issue is primarily how NetworkVariables handle updating and will require some additional re-factoring.
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context, GetType().Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, m_ReceivedNetworkVariableData, ref context, k_Name);
             }
         }
     }

Runtime/Messaging/Messages/ParentSyncMessage.cs

@@ -6,6 +6,8 @@ namespace Unity.Netcode
     {
         public int Version => 0;
 
+        private const string k_Name = "DestroyObjectMessage";
+
         public ulong NetworkObjectId;
 
         private byte m_BitField;
@@ -92,7 +94,7 @@ namespace Unity.Netcode
             // If the target NetworkObject does not exist =or= the target latest parent does not exist then defer the message
             if (!networkManager.SpawnManager.SpawnedObjects.ContainsKey(NetworkObjectId) || (LatestParent.HasValue && !networkManager.SpawnManager.SpawnedObjects.ContainsKey(LatestParent.Value)))
             {
-                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, GetType().Name);
+                networkManager.DeferredMessageManager.DeferMessage(IDeferredNetworkMessageManager.TriggerType.OnSpawn, NetworkObjectId, reader, ref context, k_Name);
                 return false;
             }
             return true;

Runtime/Messaging/Messages/RpcMessages.cs

@@ -99,6 +99,8 @@ namespace Unity.Netcode
         public FastBufferWriter WriteBuffer;
         public FastBufferReader ReadBuffer;
 
+        private const string k_Name = "ServerRpcMessage";
+
         public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
         {
             RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
@@ -106,7 +108,7 @@ namespace Unity.Netcode
 
         public unsafe bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
-            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, k_Name);
         }
 
         public void Handle(ref NetworkContext context)
@@ -134,6 +136,8 @@ namespace Unity.Netcode
         public FastBufferWriter WriteBuffer;
         public FastBufferReader ReadBuffer;
 
+        private const string k_Name = "ClientRpcMessage";
+
         public void Serialize(FastBufferWriter writer, int targetVersion)
         {
             RpcMessageHelpers.Serialize(ref writer, ref Metadata, ref WriteBuffer);
@@ -141,7 +145,7 @@ namespace Unity.Netcode
 
         public bool Deserialize(FastBufferReader reader, ref NetworkContext context, int receivedMessageVersion)
         {
-            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, k_Name);
         }
 
         public void Handle(ref NetworkContext context)
@@ -169,6 +173,8 @@ namespace Unity.Netcode
         public FastBufferWriter WriteBuffer;
         public FastBufferReader ReadBuffer;
 
+        private const string k_Name = "RpcMessage";
+
         public unsafe void Serialize(FastBufferWriter writer, int targetVersion)
         {
             BytePacker.WriteValuePacked(writer, SenderClientId);
@@ -179,7 +185,7 @@ namespace Unity.Netcode
         {
             ByteUnpacker.ReadValuePacked(reader, out SenderClientId);
 
-            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, GetType().Name);
+            return RpcMessageHelpers.Deserialize(ref reader, ref context, ref Metadata, ref ReadBuffer, k_Name);
         }
 
         public void Handle(ref NetworkContext context)

Runtime/Messaging/NetworkMessageManager.cs

@@ -34,6 +34,9 @@ namespace Unity.Netcode
     internal class NetworkMessageManager : IDisposable
     {
         public bool StopProcessing = false;
+        private static Type s_ConnectionApprovedType = typeof(ConnectionApprovedMessage);
+        private static Type s_ConnectionRequestType = typeof(ConnectionRequestMessage);
+        private static Type s_DisconnectReasonType = typeof(DisconnectReasonMessage);
 
         private struct ReceiveQueueItem
         {
@@ -120,49 +123,20 @@ namespace Unity.Netcode
             public VersionGetter GetVersion;
         }
 
-        internal List<MessageWithHandler> PrioritizeMessageOrder(List<MessageWithHandler> allowedTypes)
-        {
-            var prioritizedTypes = new List<MessageWithHandler>();
-
-            // First pass puts the priority message in the first indices
-            // Those are the messages that must be delivered in order to allow re-ordering the others later
-            foreach (var t in allowedTypes)
-            {
-                if (t.MessageType.FullName == typeof(ConnectionRequestMessage).FullName ||
-                    t.MessageType.FullName == typeof(ConnectionApprovedMessage).FullName)
-                {
-                    prioritizedTypes.Add(t);
-                }
-            }
-
-            foreach (var t in allowedTypes)
-            {
-                if (t.MessageType.FullName != typeof(ConnectionRequestMessage).FullName &&
-                    t.MessageType.FullName != typeof(ConnectionApprovedMessage).FullName)
-                {
-                    prioritizedTypes.Add(t);
-                }
-            }
-
-            return prioritizedTypes;
-        }
-
         public NetworkMessageManager(INetworkMessageSender sender, object owner, INetworkMessageProvider provider = null)
         {
             try
             {
                 m_Sender = sender;
                 m_Owner = owner;
-
                 if (provider == null)
                 {
                     provider = new ILPPMessageProvider();
                 }
 
+                // Get the presorted message types returned by the provider
                 var allowedTypes = provider.GetMessages();
 
-                allowedTypes.Sort((a, b) => string.CompareOrdinal(a.MessageType.FullName, b.MessageType.FullName));
-                allowedTypes = PrioritizeMessageOrder(allowedTypes);
                 foreach (var type in allowedTypes)
                 {
                     RegisterMessageType(type);
@@ -553,6 +527,7 @@ namespace Unity.Netcode
             return new T().Version;
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal int GetMessageVersion(Type type, ulong clientId, bool forReceive = false)
         {
             if (!m_PerClientMessageVersions.TryGetValue(clientId, out var versionMap))
@@ -580,16 +555,20 @@ namespace Unity.Netcode
             return messageVersion;
         }
 
+
+
         public static void ReceiveMessage<T>(FastBufferReader reader, ref NetworkContext context, NetworkMessageManager manager) where T : INetworkMessage, new()
         {
+            var messageType = typeof(T);
             var message = new T();
             var messageVersion = 0;
+
             // Special cases because these are the messages that carry the version info - thus the version info isn't
             // populated yet when we get these. The first part of these messages always has to be the version data
             // and can't change.
-            if (typeof(T) != typeof(ConnectionRequestMessage) && typeof(T) != typeof(ConnectionApprovedMessage) && typeof(T) != typeof(DisconnectReasonMessage) && context.SenderId != manager.m_LocalClientId)
+            if (messageType != s_ConnectionRequestType && messageType != s_ConnectionApprovedType && messageType != s_DisconnectReasonType && context.SenderId != manager.m_LocalClientId)
             {
-                messageVersion = manager.GetMessageVersion(typeof(T), context.SenderId, true);
+                messageVersion = manager.GetMessageVersion(messageType, context.SenderId, true);
                 if (messageVersion < 0)
                 {
                     return;
@@ -641,7 +620,7 @@ namespace Unity.Netcode
                 var messageVersion = 0;
                 // Special case because this is the message that carries the version info - thus the version info isn't populated yet when we get this.
                 // The first part of this message always has to be the version data and can't change.
-                if (typeof(TMessageType) != typeof(ConnectionRequestMessage))
+                if (typeof(TMessageType) != s_ConnectionRequestType)
                 {
                     messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
                     if (messageVersion < 0)
@@ -695,7 +674,7 @@ namespace Unity.Netcode
 
                 // Special case because this is the message that carries the version info - thus the version info isn't populated yet when we get this.
                 // The first part of this message always has to be the version data and can't change.
-                if (typeof(TMessageType) != typeof(ConnectionRequestMessage))
+                if (typeof(TMessageType) != s_ConnectionRequestType)
                 {
                     var messageVersion = GetMessageVersion(typeof(TMessageType), clientIds[i]);
                     if (messageVersion < 0)
@@ -775,7 +754,7 @@ namespace Unity.Netcode
             // Special case because this is the message that carries the version info - thus the version info isn't
             // populated yet when we get this. The first part of this message always has to be the version data
             // and can't change.
-            if (typeof(TMessageType) != typeof(ConnectionRequestMessage))
+            if (typeof(TMessageType) != s_ConnectionRequestType)
             {
                 messageVersion = GetMessageVersion(typeof(TMessageType), clientId);
                 if (messageVersion < 0)

Runtime/Messaging/RpcTargets/EveryoneRpcTarget.cs

@@ -4,23 +4,37 @@ namespace Unity.Netcode
     {
         private NotServerRpcTarget m_NotServerRpcTarget;
         private ServerRpcTarget m_ServerRpcTarget;
+        private NotAuthorityRpcTarget m_NotAuthorityRpcTarget;
+        private AuthorityRpcTarget m_AuthorityRpcTarget;
 
         public override void Dispose()
         {
             m_NotServerRpcTarget.Dispose();
             m_ServerRpcTarget.Dispose();
+            m_NotAuthorityRpcTarget.Dispose();
+            m_AuthorityRpcTarget.Dispose();
         }
 
         internal override void Send(NetworkBehaviour behaviour, ref RpcMessage message, NetworkDelivery delivery, RpcParams rpcParams)
         {
-            m_NotServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+            if (NetworkManager.IsDistributedAuthority)
-            m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+            {
+                m_NotAuthorityRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+                m_AuthorityRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+            }
+            else
+            {
+                m_NotServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+                m_ServerRpcTarget.Send(behaviour, ref message, delivery, rpcParams);
+            }
         }
 
         internal EveryoneRpcTarget(NetworkManager manager) : base(manager)
         {
             m_NotServerRpcTarget = new NotServerRpcTarget(manager);
             m_ServerRpcTarget = new ServerRpcTarget(manager);
+            m_NotAuthorityRpcTarget = new NotAuthorityRpcTarget(manager);
+            m_AuthorityRpcTarget = new AuthorityRpcTarget(manager);
         }
     }
 }

Runtime/NetworkVariable/AnticipatedNetworkVariable.cs

@@ -0,0 +1,392 @@
+using System;
+using Unity.Mathematics;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+
+    public enum StaleDataHandling
+    {
+        Ignore,
+        Reanticipate
+    }
+
+#pragma warning disable IDE0001
+    /// <summary>
+    /// A variable that can be synchronized over the network.
+    /// This version supports basic client anticipation - the client can set a value on the belief that the server
+    /// will update it to reflect the same value in a future update (i.e., as the result of an RPC call).
+    /// This value can then be adjusted as new updates from the server come in, in three basic modes:
+    ///
+    /// <list type="bullet">
+    ///
+    /// <item><b>Snap:</b> In this mode (with <see cref="StaleDataHandling"/> set to
+    /// <see cref="Netcode.StaleDataHandling.Ignore"/> and no <see cref="NetworkBehaviour.OnReanticipate"/> callback),
+    /// the moment a more up-to-date value is received from the authority, it will simply replace the anticipated value,
+    /// resulting in a "snap" to the new value if it is different from the anticipated value.</item>
+    ///
+    /// <item><b>Smooth:</b> In this mode (with <see cref="StaleDataHandling"/> set to
+    /// <see cref="Netcode.StaleDataHandling.Ignore"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> callback that calls
+    /// <see cref="Smooth"/> from the anticipated value to the authority value with an appropriate
+    /// <see cref="Mathf.Lerp"/>-style smooth function), when a more up-to-date value is received from the authority,
+    /// it will interpolate over time from an incorrect anticipated value to the correct authoritative value.</item>
+    ///
+    /// <item><b>Constant Reanticipation:</b> In this mode (with <see cref="StaleDataHandling"/> set to
+    /// <see cref="Netcode.StaleDataHandling.Reanticipate"/> and an <see cref="NetworkBehaviour.OnReanticipate"/> that calculates a
+    /// new anticipated value based on the current authoritative value), when a more up-to-date value is received from
+    /// the authority, user code calculates a new anticipated value, possibly calling <see cref="Smooth"/> to interpolate
+    /// between the previous anticipation and the new anticipation. This is useful for values that change frequently and
+    /// need to constantly be re-evaluated, as opposed to values that change only in response to user action and simply
+    /// need a one-time anticipation when the user performs that action.</item>
+    ///
+    /// </list>
+    ///
+    /// Note that these three modes may be combined. For example, if an <see cref="NetworkBehaviour.OnReanticipate"/> callback
+    /// does not call either <see cref="Smooth"/> or <see cref="Anticipate"/>, the result will be a snap to the
+    /// authoritative value, enabling for a callback that may conditionally call <see cref="Smooth"/> when the
+    /// difference between the anticipated and authoritative values is within some threshold, but fall back to
+    /// snap behavior if the difference is too large.
+    /// </summary>
+    /// <typeparam name="T">the unmanaged type for <see cref="NetworkVariable{T}"/> </typeparam>
+#pragma warning restore IDE0001
+    [Serializable]
+    [GenerateSerializationForGenericParameter(0)]
+    public class AnticipatedNetworkVariable<T> : NetworkVariableBase
+    {
+        [SerializeField]
+        private NetworkVariable<T> m_AuthoritativeValue;
+        private T m_AnticipatedValue;
+        private T m_PreviousAnticipatedValue;
+        private ulong m_LastAuthorityUpdateCounter = 0;
+        private ulong m_LastAnticipationCounter = 0;
+        private bool m_IsDisposed = false;
+        private bool m_SettingAuthoritativeValue = false;
+
+        private T m_SmoothFrom;
+        private T m_SmoothTo;
+        private float m_SmoothDuration;
+        private float m_CurrentSmoothTime;
+        private bool m_HasSmoothValues;
+
+#pragma warning disable IDE0001
+        /// <summary>
+        /// Defines what the behavior should be if we receive a value from the server with an earlier associated
+        /// time value than the anticipation time value.
+        /// <br/><br/>
+        /// If this is <see cref="Netcode.StaleDataHandling.Ignore"/>, the stale data will be ignored and the authoritative
+        /// value will not replace the anticipated value until the anticipation time is reached. <see cref="OnAuthoritativeValueChanged"/>
+        /// and <see cref="NetworkBehaviour.OnReanticipate"/> will also not be invoked for this stale data.
+        /// <br/><br/>
+        /// If this is <see cref="Netcode.StaleDataHandling.Reanticipate"/>, the stale data will replace the anticipated data and
+        /// <see cref="OnAuthoritativeValueChanged"/> and <see cref="NetworkBehaviour.OnReanticipate"/> will be invoked.
+        /// In this case, the authoritativeTime value passed to <see cref="NetworkBehaviour.OnReanticipate"/> will be lower than
+        /// the anticipationTime value, and that callback can be used to calculate a new anticipated value.
+        /// </summary>
+#pragma warning restore IDE0001
+        public StaleDataHandling StaleDataHandling;
+
+        public delegate void OnAuthoritativeValueChangedDelegate(AnticipatedNetworkVariable<T> variable, in T previousValue, in T newValue);
+
+        /// <summary>
+        /// Invoked any time the authoritative value changes, even when the data is stale or has been changed locally.
+        /// </summary>
+        public OnAuthoritativeValueChangedDelegate OnAuthoritativeValueChanged = null;
+
+        /// <summary>
+        /// Determines if the difference between the last serialized value and the current value is large enough
+        /// to serialize it again.
+        /// </summary>
+        public event NetworkVariable<T>.CheckExceedsDirtinessThresholdDelegate CheckExceedsDirtinessThreshold
+        {
+            add => m_AuthoritativeValue.CheckExceedsDirtinessThreshold += value;
+            remove => m_AuthoritativeValue.CheckExceedsDirtinessThreshold -= value;
+        }
+
+        private class AnticipatedObject : IAnticipatedObject
+        {
+            public AnticipatedNetworkVariable<T> Variable;
+
+            public void Update()
+            {
+                Variable.Update();
+            }
+
+            public void ResetAnticipation()
+            {
+                Variable.ShouldReanticipate = false;
+            }
+
+            public NetworkObject OwnerObject => Variable.m_NetworkBehaviour.NetworkObject;
+        }
+
+        private AnticipatedObject m_AnticipatedObject;
+
+        public override void OnInitialize()
+        {
+            m_AuthoritativeValue.Initialize(m_NetworkBehaviour);
+            NetworkVariableSerialization<T>.Duplicate(m_AuthoritativeValue.Value, ref m_AnticipatedValue);
+            NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
+            if (m_NetworkBehaviour != null && m_NetworkBehaviour.NetworkManager != null && m_NetworkBehaviour.NetworkManager.AnticipationSystem != null)
+            {
+                m_AnticipatedObject = new AnticipatedObject { Variable = this };
+                m_NetworkBehaviour.NetworkManager.AnticipationSystem.AllAnticipatedObjects.Add(m_AnticipatedObject);
+            }
+        }
+
+        public override bool ExceedsDirtinessThreshold()
+        {
+            return m_AuthoritativeValue.ExceedsDirtinessThreshold();
+        }
+
+        /// <summary>
+        /// Retrieves the current value for the variable.
+        /// This is the "display value" for this variable, and is affected by <see cref="Anticipate"/> and
+        /// <see cref="Smooth"/>, as well as by updates from the authority, depending on <see cref="StaleDataHandling"/>
+        /// and the behavior of any <see cref="NetworkBehaviour.OnReanticipate"/> callbacks.
+        /// <br /><br />
+        /// When a server update arrives, this value will be overwritten
+        /// by the new server value (unless stale data handling is set
+        /// to "Ignore" and the update is determined to be stale).
+        /// This value will be duplicated in
+        /// <see cref="PreviousAnticipatedValue"/>, which
+        /// will NOT be overwritten in server updates.
+        /// </summary>
+        public T Value => m_AnticipatedValue;
+
+        /// <summary>
+        /// Indicates whether this variable currently needs
+        /// reanticipation. If this is true, the anticipated value
+        /// has been overwritten by the authoritative value from the
+        /// server; the previous anticipated value is stored in <see cref="PreviousAnticipatedState"/>
+        /// </summary>
+        public bool ShouldReanticipate
+        {
+            get;
+            private set;
+        }
+
+        /// <summary>
+        /// Holds the most recent anticipated value, whatever was
+        /// most recently set using <see cref="Anticipate"/>. Unlike
+        /// <see cref="Value"/>, this does not get overwritten
+        /// when a server update arrives.
+        /// </summary>
+        public T PreviousAnticipatedValue => m_PreviousAnticipatedValue;
+
+        /// <summary>
+        /// Sets the current value of the variable on the expectation that the authority will set the variable
+        /// to the same value within one network round trip (i.e., in response to an RPC).
+        /// </summary>
+        /// <param name="value"></param>
+        public void Anticipate(T value)
+        {
+            if (m_NetworkBehaviour.NetworkManager.ShutdownInProgress || !m_NetworkBehaviour.NetworkManager.IsListening)
+            {
+                return;
+            }
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+            m_LastAnticipationCounter = m_NetworkBehaviour.NetworkManager.AnticipationSystem.AnticipationCounter;
+            m_AnticipatedValue = value;
+            NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
+            if (CanClientWrite(m_NetworkBehaviour.NetworkManager.LocalClientId))
+            {
+                AuthoritativeValue = value;
+            }
+        }
+
+#pragma warning disable IDE0001
+        /// <summary>
+        /// Retrieves or sets the underlying authoritative value.
+        /// Note that only a client or server with write permissions to this variable may set this value.
+        /// When this variable has been anticipated, this value will alawys return the most recent authoritative
+        /// state, which is updated even if <see cref="StaleDataHandling"/> is <see cref="Netcode.StaleDataHandling.Ignore"/>.
+        /// </summary>
+#pragma warning restore IDE0001
+        public T AuthoritativeValue
+        {
+            get => m_AuthoritativeValue.Value;
+            set
+            {
+                m_SettingAuthoritativeValue = true;
+                try
+                {
+                    m_AuthoritativeValue.Value = value;
+                    m_AnticipatedValue = value;
+                    NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
+                }
+                finally
+                {
+                    m_SettingAuthoritativeValue = false;
+                }
+            }
+        }
+
+        /// <summary>
+        /// A function to interpolate between two values based on a percentage.
+        /// See <see cref="Mathf.Lerp"/>, <see cref="Vector3.Lerp"/>, <see cref="Vector3.Slerp"/>, and so on
+        /// for examples.
+        /// </summary>
+        public delegate T SmoothDelegate(T authoritativeValue, T anticipatedValue, float amount);
+
+        private SmoothDelegate m_SmoothDelegate = null;
+
+        public AnticipatedNetworkVariable(T value = default,
+            StaleDataHandling staleDataHandling = StaleDataHandling.Ignore)
+            : base()
+        {
+            StaleDataHandling = staleDataHandling;
+            m_AuthoritativeValue = new NetworkVariable<T>(value)
+            {
+                OnValueChanged = OnValueChangedInternal
+            };
+        }
+
+        public void Update()
+        {
+            if (m_CurrentSmoothTime < m_SmoothDuration)
+            {
+                m_CurrentSmoothTime += m_NetworkBehaviour.NetworkManager.RealTimeProvider.DeltaTime;
+                var pct = math.min(m_CurrentSmoothTime / m_SmoothDuration, 1f);
+                m_AnticipatedValue = m_SmoothDelegate(m_SmoothFrom, m_SmoothTo, pct);
+                NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
+            }
+        }
+
+        public override void Dispose()
+        {
+            if (m_IsDisposed)
+            {
+                return;
+            }
+
+            if (m_NetworkBehaviour != null && m_NetworkBehaviour.NetworkManager != null && m_NetworkBehaviour.NetworkManager.AnticipationSystem != null)
+            {
+                if (m_AnticipatedObject != null)
+                {
+                    m_NetworkBehaviour.NetworkManager.AnticipationSystem.AllAnticipatedObjects.Remove(m_AnticipatedObject);
+                    m_NetworkBehaviour.NetworkManager.AnticipationSystem.ObjectsToReanticipate.Remove(m_AnticipatedObject);
+                    m_AnticipatedObject = null;
+                }
+            }
+
+            m_IsDisposed = true;
+
+            m_AuthoritativeValue.Dispose();
+            if (m_AnticipatedValue is IDisposable anticipatedValueDisposable)
+            {
+                anticipatedValueDisposable.Dispose();
+            }
+
+            m_AnticipatedValue = default;
+            if (m_PreviousAnticipatedValue is IDisposable previousValueDisposable)
+            {
+                previousValueDisposable.Dispose();
+                m_PreviousAnticipatedValue = default;
+            }
+
+            if (m_HasSmoothValues)
+            {
+                if (m_SmoothFrom is IDisposable smoothFromDisposable)
+                {
+                    smoothFromDisposable.Dispose();
+                    m_SmoothFrom = default;
+                }
+                if (m_SmoothTo is IDisposable smoothToDisposable)
+                {
+                    smoothToDisposable.Dispose();
+                    m_SmoothTo = default;
+                }
+
+                m_HasSmoothValues = false;
+            }
+        }
+
+        ~AnticipatedNetworkVariable()
+        {
+            Dispose();
+        }
+
+        private void OnValueChangedInternal(T previousValue, T newValue)
+        {
+            if (!m_SettingAuthoritativeValue)
+            {
+                m_LastAuthorityUpdateCounter = m_NetworkBehaviour.NetworkManager.AnticipationSystem.LastAnticipationAck;
+                if (StaleDataHandling == StaleDataHandling.Ignore && m_LastAnticipationCounter > m_LastAuthorityUpdateCounter)
+                {
+                    // Keep the anticipated value unchanged because it is more recent than the authoritative one.
+                    return;
+                }
+
+
+                ShouldReanticipate = true;
+                m_NetworkBehaviour.NetworkManager.AnticipationSystem.ObjectsToReanticipate.Add(m_AnticipatedObject);
+            }
+
+            NetworkVariableSerialization<T>.Duplicate(AuthoritativeValue, ref m_AnticipatedValue);
+
+            m_SmoothDuration = 0;
+            m_CurrentSmoothTime = 0;
+            OnAuthoritativeValueChanged?.Invoke(this, previousValue, newValue);
+        }
+
+        /// <summary>
+        /// Interpolate this variable from <see cref="from"/> to <see cref="to"/> over <see cref="durationSeconds"/> of
+        /// real time. The duration uses <see cref="Time.deltaTime"/>, so it is affected by <see cref="Time.timeScale"/>.
+        /// </summary>
+        /// <param name="from"></param>
+        /// <param name="to"></param>
+        /// <param name="durationSeconds"></param>
+        /// <param name="how"></param>
+        public void Smooth(in T from, in T to, float durationSeconds, SmoothDelegate how)
+        {
+            if (durationSeconds <= 0)
+            {
+                NetworkVariableSerialization<T>.Duplicate(to, ref m_AnticipatedValue);
+                m_SmoothDuration = 0;
+                m_CurrentSmoothTime = 0;
+                m_SmoothDelegate = null;
+                return;
+            }
+            NetworkVariableSerialization<T>.Duplicate(from, ref m_AnticipatedValue);
+            NetworkVariableSerialization<T>.Duplicate(from, ref m_SmoothFrom);
+            NetworkVariableSerialization<T>.Duplicate(to, ref m_SmoothTo);
+            m_SmoothDuration = durationSeconds;
+            m_CurrentSmoothTime = 0;
+            m_SmoothDelegate = how;
+            m_HasSmoothValues = true;
+        }
+
+        public override bool IsDirty()
+        {
+            return m_AuthoritativeValue.IsDirty();
+        }
+
+        public override void ResetDirty()
+        {
+            m_AuthoritativeValue.ResetDirty();
+        }
+
+        public override void WriteDelta(FastBufferWriter writer)
+        {
+            m_AuthoritativeValue.WriteDelta(writer);
+        }
+
+        public override void WriteField(FastBufferWriter writer)
+        {
+            m_AuthoritativeValue.WriteField(writer);
+        }
+
+        public override void ReadField(FastBufferReader reader)
+        {
+            m_AuthoritativeValue.ReadField(reader);
+            NetworkVariableSerialization<T>.Duplicate(m_AuthoritativeValue.Value, ref m_AnticipatedValue);
+            NetworkVariableSerialization<T>.Duplicate(m_AnticipatedValue, ref m_PreviousAnticipatedValue);
+        }
+
+        public override void ReadDelta(FastBufferReader reader, bool keepDirtyDelta)
+        {
+            m_AuthoritativeValue.ReadDelta(reader, keepDirtyDelta);
+        }
+    }
+}

Runtime/NetworkVariable/AnticipatedNetworkVariable.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: fc9fd5701bee8534a971eb9f49178e21

Runtime/NetworkVariable/NetworkVariable.cs

@@ -21,6 +21,29 @@ namespace Unity.Netcode
         /// The callback to be invoked when the value gets changed
         /// </summary>
         public OnValueChangedDelegate OnValueChanged;
+
+        public delegate bool CheckExceedsDirtinessThresholdDelegate(in T previousValue, in T newValue);
+
+        public CheckExceedsDirtinessThresholdDelegate CheckExceedsDirtinessThreshold;
+
+        public override bool ExceedsDirtinessThreshold()
+        {
+            if (CheckExceedsDirtinessThreshold != null && m_HasPreviousValue)
+            {
+                return CheckExceedsDirtinessThreshold(m_PreviousValue, m_InternalValue);
+            }
+
+            return true;
+        }
+
+        public override void OnInitialize()
+        {
+            base.OnInitialize();
+
+            m_HasPreviousValue = true;
+            NetworkVariableSerialization<T>.Duplicate(m_InternalValue, ref m_PreviousValue);
+        }
+
         internal override NetworkVariableType Type => NetworkVariableType.Value;
 
         /// <summary>

Runtime/NetworkVariable/NetworkVariableBase.cs

@@ -3,11 +3,26 @@ using UnityEngine;
 
 namespace Unity.Netcode
 {
+    public struct NetworkVariableUpdateTraits
+    {
+        [Tooltip("The minimum amount of time that must pass between sending updates. If this amount of time has not passed since the last update, dirtiness will be ignored.")]
+        public float MinSecondsBetweenUpdates;
+
+        [Tooltip("The maximum amount of time that a variable can be dirty without sending an update. If this amount of time has passed since the last update, an update will be sent even if the dirtiness threshold has not been met.")]
+        public float MaxSecondsBetweenUpdates;
+    }
+
     /// <summary>
     /// Interface for network value containers
     /// </summary>
     public abstract class NetworkVariableBase : IDisposable
     {
+        [SerializeField]
+        internal NetworkVariableUpdateTraits UpdateTraits = default;
+
+        [NonSerialized]
+        internal double LastUpdateSent;
+
         /// <summary>
         /// The delivery type (QoS) to send data with
         /// </summary>
@@ -52,7 +67,42 @@ namespace Unity.Netcode
                 m_InternalNetworkManager = m_NetworkBehaviour.NetworkObject?.NetworkManager;
                 // When in distributed authority mode, there is no such thing as server write permissions
                 InternalWritePerm = m_InternalNetworkManager.DistributedAuthorityMode ? NetworkVariableWritePermission.Owner : InternalWritePerm;
+
+                if (m_NetworkBehaviour.NetworkManager.NetworkTimeSystem != null)
+                {
+                    UpdateLastSentTime();
+                }
             }
+
+            OnInitialize();
+        }
+
+        /// <summary>
+        /// Called on initialization
+        /// </summary>
+        public virtual void OnInitialize()
+        {
+
+        }
+
+        /// <summary>
+        /// Sets the update traits for this network variable to determine how frequently it will send updates.
+        /// </summary>
+        /// <param name="traits"></param>
+        public void SetUpdateTraits(NetworkVariableUpdateTraits traits)
+        {
+            UpdateTraits = traits;
+        }
+
+        /// <summary>
+        /// Check whether or not this variable has changed significantly enough to send an update.
+        /// If not, no update will be sent even if the variable is dirty, unless the time since last update exceeds
+        /// the <see cref="UpdateTraits"/>' <see cref="NetworkVariableUpdateTraits.MaxSecondsBetweenUpdates"/>.
+        /// </summary>
+        /// <returns></returns>
+        public virtual bool ExceedsDirtinessThreshold()
+        {
+            return true;
         }
 
         /// <summary>
@@ -125,6 +175,25 @@ namespace Unity.Netcode
             }
         }
 
+        internal bool CanSend()
+        {
+            var timeSinceLastUpdate = m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime - LastUpdateSent;
+            return
+                (
+                    UpdateTraits.MaxSecondsBetweenUpdates > 0 &&
+                    timeSinceLastUpdate >= UpdateTraits.MaxSecondsBetweenUpdates
+                ) ||
+                (
+                    timeSinceLastUpdate >= UpdateTraits.MinSecondsBetweenUpdates &&
+                    ExceedsDirtinessThreshold()
+                );
+        }
+
+        internal void UpdateLastSentTime()
+        {
+            LastUpdateSent = m_NetworkBehaviour.NetworkManager.NetworkTimeSystem.LocalTime;
+        }
+
         internal static bool IgnoreInitializeWarning;
 
         protected void MarkNetworkBehaviourDirty()
@@ -147,6 +216,17 @@ namespace Unity.Netcode
                 }
                 return;
             }
+
+            if (!m_NetworkBehaviour.NetworkManager.IsListening)
+            {
+                if (m_NetworkBehaviour.NetworkManager.LogLevel <= LogLevel.Developer)
+                {
+                    Debug.LogWarning($"NetworkVariable is written to after the NetworkManager has already shutdown! " +
+                     "Are you modifying a NetworkVariable within a NetworkBehaviour.OnDestroy or NetworkBehaviour.OnDespawn method?");
+                }
+                return;
+            }
+
             m_NetworkBehaviour.NetworkManager.BehaviourUpdater?.AddForUpdate(m_NetworkBehaviour.NetworkObject);
         }
 

Runtime/NetworkVariable/NetworkVariableSerialization.cs.meta

@@ -1,3 +0,0 @@
-fileFormatVersion: 2
-guid: 2c6ef5fdf2e94ec3b4ce8086d52700b3
-timeCreated: 1650985453

Runtime/NetworkVariable/Serialization.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d960ae6c5b8241aa9e2906b709095ea1
+timeCreated: 1718215841

Runtime/NetworkVariable/Serialization/FallbackSerializer.cs

@@ -0,0 +1,99 @@
+using System;
+using Unity.Collections;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This class is instantiated for types that we can't determine ahead of time are serializable - types
+    /// that don't meet any of the constraints for methods that are available on FastBufferReader and
+    /// FastBufferWriter. These types may or may not be serializable through extension methods. To ensure
+    /// the user has time to pass in the delegates to UserNetworkVariableSerialization, the existence
+    /// of user serialization isn't checked until it's used, so if no serialization is provided, this
+    /// will throw an exception when an object containing the relevant NetworkVariable is spawned.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    internal class FallbackSerializer<T> : INetworkVariableSerializer<T>
+    {
+        private void ThrowArgumentError()
+        {
+            throw new ArgumentException($"Serialization has not been generated for type {typeof(T).FullName}. This can be addressed by adding a [{nameof(GenerateSerializationForGenericParameterAttribute)}] to your generic class that serializes this value (if you are using one), adding [{nameof(GenerateSerializationForTypeAttribute)}(typeof({typeof(T).FullName})] to the class or method that is attempting to serialize it, or creating a field on a {nameof(NetworkBehaviour)} of type {nameof(NetworkVariable<T>)}. If this error continues to appear after doing one of those things and this is a type you can change, then either implement {nameof(INetworkSerializable)} or mark it as serializable by memcpy by adding {nameof(INetworkSerializeByMemcpy)} to its interface list to enable automatic serialization generation. If not, assign serialization code to {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.WriteValue)}, {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.ReadValue)}, and {nameof(UserNetworkVariableSerialization<T>)}.{nameof(UserNetworkVariableSerialization<T>.DuplicateValue)}, or if it's serializable by memcpy (contains no pointers), wrap it in {typeof(ForceNetworkSerializeByMemcpy<>).Name}.");
+        }
+
+        public void Write(FastBufferWriter writer, ref T value)
+        {
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
+            {
+                ThrowArgumentError();
+            }
+            UserNetworkVariableSerialization<T>.WriteValue(writer, value);
+        }
+        public void Read(FastBufferReader reader, ref T value)
+        {
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
+            {
+                ThrowArgumentError();
+            }
+            UserNetworkVariableSerialization<T>.ReadValue(reader, out value);
+        }
+
+        public void WriteDelta(FastBufferWriter writer, ref T value, ref T previousValue)
+        {
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
+            {
+                ThrowArgumentError();
+            }
+
+            if (UserNetworkVariableSerialization<T>.WriteDelta == null || UserNetworkVariableSerialization<T>.ReadDelta == null)
+            {
+                UserNetworkVariableSerialization<T>.WriteValue(writer, value);
+                return;
+            }
+            UserNetworkVariableSerialization<T>.WriteDelta(writer, value, previousValue);
+        }
+
+        public void ReadDelta(FastBufferReader reader, ref T value)
+        {
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
+            {
+                ThrowArgumentError();
+            }
+
+            if (UserNetworkVariableSerialization<T>.WriteDelta == null || UserNetworkVariableSerialization<T>.ReadDelta == null)
+            {
+                UserNetworkVariableSerialization<T>.ReadValue(reader, out value);
+                return;
+            }
+            UserNetworkVariableSerialization<T>.ReadDelta(reader, ref value);
+        }
+
+        void INetworkVariableSerializer<T>.ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Duplicate(in T value, ref T duplicatedValue)
+        {
+            if (UserNetworkVariableSerialization<T>.ReadValue == null || UserNetworkVariableSerialization<T>.WriteValue == null || UserNetworkVariableSerialization<T>.DuplicateValue == null)
+            {
+                ThrowArgumentError();
+            }
+            UserNetworkVariableSerialization<T>.DuplicateValue(value, ref duplicatedValue);
+        }
+    }
+
+    // RuntimeAccessModifiersILPP will make this `public`
+    // This is just pass-through to NetworkVariableSerialization<T> but is here because I could not get ILPP
+    // to generate code that would successfully call Type<T>.Method(T), but it has no problem calling Type.Method<T>(T)
+    internal class RpcFallbackSerialization
+    {
+        public static void Write<T>(FastBufferWriter writer, ref T value)
+        {
+            NetworkVariableSerialization<T>.Write(writer, ref value);
+        }
+
+        public static void Read<T>(FastBufferReader reader, ref T value)
+        {
+            NetworkVariableSerialization<T>.Read(reader, ref value);
+        }
+    }
+}

Runtime/NetworkVariable/Serialization/FallbackSerializer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 288dbe7d1ff74860ae3552c034485538
+timeCreated: 1718219109

Runtime/NetworkVariable/Serialization/INetworkVariableSerializer.cs

@@ -0,0 +1,26 @@
+using Unity.Collections;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// Interface used by NetworkVariables to serialize them
+    /// </summary>
+    ///
+    /// <typeparam name="T"></typeparam>
+    internal interface INetworkVariableSerializer<T>
+    {
+        // Write has to be taken by ref here because of INetworkSerializable
+        // Open Instance Delegates (pointers to methods without an instance attached to them)
+        // require the first parameter passed to them (the instance) to be passed by ref.
+        // So foo.Bar() becomes BarDelegate(ref foo);
+        // Taking T as an in parameter like we do in other places would require making a copy
+        // of it to pass it as a ref parameter.,
+
+        public void Write(FastBufferWriter writer, ref T value);
+        public void Read(FastBufferReader reader, ref T value);
+        public void WriteDelta(FastBufferWriter writer, ref T value, ref T previousValue);
+        public void ReadDelta(FastBufferReader reader, ref T value);
+        internal void ReadWithAllocator(FastBufferReader reader, out T value, Allocator allocator);
+        public void Duplicate(in T value, ref T duplicatedValue);
+    }
+}

Runtime/NetworkVariable/Serialization/INetworkVariableSerializer.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f78e258ef55f4ee89bc3f24d67b8d242
+timeCreated: 1718218205

Runtime/NetworkVariable/Serialization/NetworkVariableEquality.cs

@@ -0,0 +1,357 @@
+using System;
+using System.Collections.Generic;
+using Unity.Collections;
+using Unity.Collections.LowLevel.Unsafe;
+using Unity.Netcode;
+
+namespace Unity.Netcode
+{
+    internal static class NetworkVariableEquality<T>
+    {
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool ValueEquals<TValueType>(ref TValueType a, ref TValueType b) where TValueType : unmanaged
+        {
+            // get unmanaged pointers
+            var aptr = UnsafeUtility.AddressOf(ref a);
+            var bptr = UnsafeUtility.AddressOf(ref b);
+
+            // compare addresses
+            return UnsafeUtility.MemCmp(aptr, bptr, sizeof(TValueType)) == 0;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool ValueEqualsList<TValueType>(ref NativeList<TValueType> a, ref NativeList<TValueType> b) where TValueType : unmanaged
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+#if UTP_TRANSPORT_2_0_ABOVE
+            var aptr = a.GetUnsafePtr();
+            var bptr = b.GetUnsafePtr();
+#else
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+#endif
+
+            return UnsafeUtility.MemCmp(aptr, bptr, sizeof(TValueType) * a.Length) == 0;
+        }
+#endif
+
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool ValueEqualsArray<TValueType>(ref NativeArray<TValueType> a, ref NativeArray<TValueType> b) where TValueType : unmanaged
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+            return UnsafeUtility.MemCmp(aptr, bptr, sizeof(TValueType) * a.Length) == 0;
+        }
+
+        internal static bool EqualityEqualsObject<TValueType>(ref TValueType a, ref TValueType b) where TValueType : class, IEquatable<TValueType>
+        {
+            if (a == null)
+            {
+                return b == null;
+            }
+
+            if (b == null)
+            {
+                return false;
+            }
+
+            return a.Equals(b);
+        }
+
+        internal static bool EqualityEquals<TValueType>(ref TValueType a, ref TValueType b) where TValueType : unmanaged, IEquatable<TValueType>
+        {
+            return a.Equals(b);
+        }
+
+        internal static bool EqualityEqualsList<TValueType>(ref List<TValueType> a, ref List<TValueType> b)
+        {
+            if (a == null != (b == null))
+            {
+                return false;
+            }
+
+            if (a == null)
+            {
+                return true;
+            }
+
+            if (a.Count != b.Count)
+            {
+                return false;
+            }
+
+            for (var i = 0; i < a.Count; ++i)
+            {
+                var aItem = a[i];
+                var bItem = b[i];
+                if (!NetworkVariableSerialization<TValueType>.AreEqual(ref aItem, ref bItem))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        internal static bool EqualityEqualsHashSet<TValueType>(ref HashSet<TValueType> a, ref HashSet<TValueType> b) where TValueType : IEquatable<TValueType>
+        {
+            if (a == null != (b == null))
+            {
+                return false;
+            }
+
+            if (a == null)
+            {
+                return true;
+            }
+
+            if (a.Count != b.Count)
+            {
+                return false;
+            }
+
+            foreach (var item in a)
+            {
+                if (!b.Contains(item))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool EqualityEqualsArray<TValueType>(ref NativeArray<TValueType> a, ref NativeArray<TValueType> b) where TValueType : unmanaged, IEquatable<TValueType>
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+            for (var i = 0; i < a.Length; ++i)
+            {
+                if (!EqualityEquals(ref aptr[i], ref bptr[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        internal static bool ClassEquals<TValueType>(ref TValueType a, ref TValueType b) where TValueType : class
+        {
+            return a == b;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        // Compares two values of the same unmanaged type by underlying memory
+        // Ignoring any overridden value checks
+        // Size is fixed
+        internal static unsafe bool EqualityEqualsNativeList<TValueType>(ref NativeList<TValueType> a, ref NativeList<TValueType> b) where TValueType : unmanaged, IEquatable<TValueType>
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+            if (a.Length != b.Length)
+            {
+                return false;
+            }
+
+#if UTP_TRANSPORT_2_0_ABOVE
+            var aptr = a.GetUnsafePtr();
+            var bptr = b.GetUnsafePtr();
+#else
+            var aptr = (TValueType*)a.GetUnsafePtr();
+            var bptr = (TValueType*)b.GetUnsafePtr();
+#endif
+            for (var i = 0; i < a.Length; ++i)
+            {
+                if (!EqualityEquals(ref aptr[i], ref bptr[i]))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+
+        internal static bool EqualityEqualsNativeHashSet<TValueType>(ref NativeHashSet<TValueType> a, ref NativeHashSet<TValueType> b) where TValueType : unmanaged, IEquatable<TValueType>
+        {
+            if (a.IsCreated != b.IsCreated)
+            {
+                return false;
+            }
+
+            if (!a.IsCreated)
+            {
+                return true;
+            }
+
+#if UTP_TRANSPORT_2_0_ABOVE
+            if (a.Count != b.Count)
+#else
+            if (a.Count() != b.Count())
+#endif
+            {
+                return false;
+            }
+
+            foreach (var item in a)
+            {
+                if (!b.Contains(item))
+                {
+                    return false;
+                }
+            }
+
+            return true;
+        }
+#endif
+    }
+}
+
+/// <summary>
+///     Support methods for equality of NetworkVariable collection types.
+///     Because there are multiple overloads of WriteValue/ReadValue based on different generic constraints,
+///     but there's no way to achieve the same thing with a class, this sets up various read/write schemes
+///     based on which constraints are met by `T` using reflection, which is done at module load time.
+/// </summary>
+/// <typeparam name="TKey">The type the associated NetworkVariable dictionary collection key templated on</typeparam>
+/// <typeparam name="TVal">The type the associated NetworkVariable dictionary collection value templated on</typeparam>
+internal class NetworkVariableDictionarySerialization<TKey, TVal>
+    where TKey : IEquatable<TKey>
+{
+    internal static bool GenericEqualsDictionary(ref Dictionary<TKey, TVal> a, ref Dictionary<TKey, TVal> b)
+    {
+        if (a == null != (b == null))
+        {
+            return false;
+        }
+
+        if (a == null)
+        {
+            return true;
+        }
+
+        if (a.Count != b.Count)
+        {
+            return false;
+        }
+
+        foreach (var item in a)
+        {
+            var hasKey = b.TryGetValue(item.Key, out var val);
+            if (!hasKey)
+            {
+                return false;
+            }
+
+            var bVal = item.Value;
+            if (!NetworkVariableSerialization<TVal>.AreEqual(ref bVal, ref val))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+internal class NetworkVariableMapSerialization<TKey, TVal>
+    where TKey : unmanaged, IEquatable<TKey>
+    where TVal : unmanaged
+{
+    internal static bool GenericEqualsNativeHashMap(ref NativeHashMap<TKey, TVal> a, ref NativeHashMap<TKey, TVal> b)
+    {
+        if (a.IsCreated != b.IsCreated)
+        {
+            return false;
+        }
+
+        if (!a.IsCreated)
+        {
+            return true;
+        }
+
+#if UTP_TRANSPORT_2_0_ABOVE
+        if (a.Count != b.Count)
+#else
+            if (a.Count() != b.Count())
+#endif
+        {
+            return false;
+        }
+
+        foreach (var item in a)
+        {
+            var hasKey = b.TryGetValue(item.Key, out var val);
+            if (!hasKey || !NetworkVariableSerialization<TVal>.AreEqual(ref item.Value, ref val))
+            {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}
+#endif

Runtime/NetworkVariable/Serialization/NetworkVariableEquality.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 24b8352a975044509931bf684ccfdb82
+timeCreated: 1718219366

Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs

@@ -0,0 +1,161 @@
+using System;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    ///     Support methods for reading/writing NetworkVariables
+    ///     Because there are multiple overloads of WriteValue/ReadValue based on different generic constraints,
+    ///     but there's no way to achieve the same thing with a class, this sets up various read/write schemes
+    ///     based on which constraints are met by `T` using reflection, which is done at module load time.
+    /// </summary>
+    /// <typeparam name="T">The type the associated NetworkVariable is templated on</typeparam>
+    [Serializable]
+    public static class NetworkVariableSerialization<T>
+    {
+        internal static INetworkVariableSerializer<T> Serializer = new FallbackSerializer<T>();
+
+        internal static bool IsDistributedAuthority => NetworkManager.IsDistributedAuthority;
+
+        /// <summary>
+        /// The collection item type tells the CMB server how to read the bytes of each item in the collection
+        /// </summary>
+        /// DANGO-EXP TODO: Determine if this is distributed authority only and impacts of this in client-server
+        internal static CollectionItemType Type = CollectionItemType.Unknown;
+
+        /// <summary>
+        /// A callback to check if two values are equal.
+        /// </summary>
+        public delegate bool EqualsDelegate(ref T a, ref T b);
+
+        /// <summary>
+        /// Uses the most efficient mechanism for a given type to determine if two values are equal.
+        /// For types that implement <see cref="IEquatable{T}"/>, it will call the Equals() method.
+        /// For unmanaged types, it will do a bytewise memory comparison.
+        /// For other types, it will call the == operator.
+        /// <br/>
+        /// <br/>
+        /// Note: If you are using this in a custom generic class, please make sure your class is
+        /// decorated with <see cref="GenerateSerializationForGenericParameterAttribute"/> so that codegen can
+        /// initialize the serialization mechanisms correctly. If your class is NOT
+        /// generic, it is better to check their equality yourself.
+        /// </summary>
+        public static EqualsDelegate AreEqual { get; internal set; }
+        /// <summary>
+        ///     Serialize a value using the best-known serialization method for a generic value.
+        ///     Will reliably serialize any value that is passed to it correctly with no boxing.
+        ///     <br />
+        ///     <br />
+        ///     Note: If you are using this in a custom generic class, please make sure your class is
+        ///     decorated with <see cref="GenerateSerializationForGenericParameterAttribute" /> so that codegen can
+        ///     initialize the serialization mechanisms correctly. If your class is NOT
+        ///     generic, it is better to use FastBufferWriter directly.
+        ///     <br />
+        ///     <br />
+        ///     If the codegen is unable to determine a serializer for a type,
+        ///     <see cref="UserNetworkVariableSerialization{T}" />.<see cref="UserNetworkVariableSerialization{T}.WriteValue" /> is called, which, by default,
+        ///     will throw an exception, unless you have assigned a user serialization callback to it at runtime.
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        public static void Write(FastBufferWriter writer, ref T value)
+        {
+            Serializer.Write(writer, ref value);
+        }
+
+        /// <summary>
+        ///     Deserialize a value using the best-known serialization method for a generic value.
+        ///     Will reliably deserialize any value that is passed to it correctly with no boxing.
+        ///     For types whose deserialization can be determined by codegen (which is most types),
+        ///     GC will only be incurred if the type is a managed type and the ref value passed in is `null`,
+        ///     in which case a new value is created; otherwise, it will be deserialized in-place.
+        ///     <br />
+        ///     <br />
+        ///     Note: If you are using this in a custom generic class, please make sure your class is
+        ///     decorated with <see cref="GenerateSerializationForGenericParameterAttribute" /> so that codegen can
+        ///     initialize the serialization mechanisms correctly. If your class is NOT
+        ///     generic, it is better to use FastBufferReader directly.
+        ///     <br />
+        ///     <br />
+        ///     If the codegen is unable to determine a serializer for a type,
+        ///     <see cref="UserNetworkVariableSerialization{T}" />.<see cref="UserNetworkVariableSerialization{T}.ReadValue" /> is called, which, by default,
+        ///     will throw an exception, unless you have assigned a user deserialization callback to it at runtime.
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="value"></param>
+        public static void Read(FastBufferReader reader, ref T value)
+        {
+            Serializer.Read(reader, ref value);
+        }
+
+        /// <summary>
+        ///     Serialize a value using the best-known serialization method for a generic value.
+        ///     Will reliably serialize any value that is passed to it correctly with no boxing.
+        ///     <br />
+        ///     <br />
+        ///     Note: If you are using this in a custom generic class, please make sure your class is
+        ///     decorated with <see cref="GenerateSerializationForGenericParameterAttribute" /> so that codegen can
+        ///     initialize the serialization mechanisms correctly. If your class is NOT
+        ///     generic, it is better to use FastBufferWriter directly.
+        ///     <br />
+        ///     <br />
+        ///     If the codegen is unable to determine a serializer for a type,
+        ///     <see cref="UserNetworkVariableSerialization{T}" />.<see cref="UserNetworkVariableSerialization{T}.WriteValue" /> is called, which, by default,
+        ///     will throw an exception, unless you have assigned a user serialization callback to it at runtime.
+        /// </summary>
+        /// <param name="writer"></param>
+        /// <param name="value"></param>
+        public static void WriteDelta(FastBufferWriter writer, ref T value, ref T previousValue)
+        {
+            Serializer.WriteDelta(writer, ref value, ref previousValue);
+        }
+
+        /// <summary>
+        ///     Deserialize a value using the best-known serialization method for a generic value.
+        ///     Will reliably deserialize any value that is passed to it correctly with no boxing.
+        ///     For types whose deserialization can be determined by codegen (which is most types),
+        ///     GC will only be incurred if the type is a managed type and the ref value passed in is `null`,
+        ///     in which case a new value is created; otherwise, it will be deserialized in-place.
+        ///     <br />
+        ///     <br />
+        ///     Note: If you are using this in a custom generic class, please make sure your class is
+        ///     decorated with <see cref="GenerateSerializationForGenericParameterAttribute" /> so that codegen can
+        ///     initialize the serialization mechanisms correctly. If your class is NOT
+        ///     generic, it is better to use FastBufferReader directly.
+        ///     <br />
+        ///     <br />
+        ///     If the codegen is unable to determine a serializer for a type,
+        ///     <see cref="UserNetworkVariableSerialization{T}" />.<see cref="UserNetworkVariableSerialization{T}.ReadValue" /> is called, which, by default,
+        ///     will throw an exception, unless you have assigned a user deserialization callback to it at runtime.
+        /// </summary>
+        /// <param name="reader"></param>
+        /// <param name="value"></param>
+        public static void ReadDelta(FastBufferReader reader, ref T value)
+        {
+            Serializer.ReadDelta(reader, ref value);
+        }
+
+        /// <summary>
+        ///     Duplicates a value using the most efficient means of creating a complete copy.
+        ///     For most types this is a simple assignment or memcpy.
+        ///     For managed types, this is will serialize and then deserialize the value to ensure
+        ///     a correct copy.
+        ///     <br />
+        ///     <br />
+        ///     Note: If you are using this in a custom generic class, please make sure your class is
+        ///     decorated with <see cref="GenerateSerializationForGenericParameterAttribute" /> so that codegen can
+        ///     initialize the serialization mechanisms correctly. If your class is NOT
+        ///     generic, it is better to duplicate it directly.
+        ///     <br />
+        ///     <br />
+        ///     If the codegen is unable to determine a serializer for a type,
+        ///     <see cref="UserNetworkVariableSerialization{T}" />.<see cref="UserNetworkVariableSerialization{T}.DuplicateValue" /> is called, which, by default,
+        ///     will throw an exception, unless you have assigned a user duplication callback to it at runtime.
+        /// </summary>
+        /// <param name="value"></param>
+        /// <param name="duplicatedValue"></param>
+        public static void Duplicate(in T value, ref T duplicatedValue)
+        {
+            Serializer.Duplicate(value, ref duplicatedValue);
+        }
+    }
+}

Runtime/NetworkVariable/Serialization/NetworkVariableSerialization.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 7a943170e35746e8913dd494d79bb63d
+timeCreated: 1718215899

Runtime/NetworkVariable/Serialization/TypedILPPInitializers.cs

@@ -0,0 +1,325 @@
+using System;
+using System.Collections.Generic;
+using Unity.Collections;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This class contains initialization functions for various different types used in NetworkVariables.
+    /// Generally speaking, these methods are called by a module initializer created by codegen (NetworkBehaviourILPP)
+    /// and do not need to be called manually.
+    ///
+    /// There are two types of initializers: Serializers and EqualityCheckers. Every type must have an EqualityChecker
+    /// registered to it in order to be used in NetworkVariable; however, not all types need a Serializer. Types without
+    /// a serializer registered will fall back to using the delegates in <see cref="UserNetworkVariableSerialization{T}"/>.
+    /// If no such delegate has been registered, a type without a serializer will throw an exception on the first attempt
+    /// to serialize or deserialize it. (Again, however, codegen handles this automatically and this registration doesn't
+    /// typically need to be performed manually.)
+    /// </summary>
+    public static class NetworkVariableSerializationTypedInitializers
+    {
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.AfterAssembliesLoaded)]
+#if UNITY_EDITOR
+        [InitializeOnLoadMethod]
+#endif
+        internal static void InitializeIntegerSerialization()
+        {
+            NetworkVariableSerialization<short>.Serializer = new ShortSerializer();
+            NetworkVariableSerialization<short>.AreEqual = NetworkVariableEquality<short>.ValueEquals;
+            NetworkVariableSerialization<ushort>.Serializer = new UshortSerializer();
+            NetworkVariableSerialization<ushort>.AreEqual = NetworkVariableEquality<ushort>.ValueEquals;
+            NetworkVariableSerialization<int>.Serializer = new IntSerializer();
+            NetworkVariableSerialization<int>.AreEqual = NetworkVariableEquality<int>.ValueEquals;
+            NetworkVariableSerialization<uint>.Serializer = new UintSerializer();
+            NetworkVariableSerialization<uint>.AreEqual = NetworkVariableEquality<uint>.ValueEquals;
+            NetworkVariableSerialization<long>.Serializer = new LongSerializer();
+            NetworkVariableSerialization<long>.AreEqual = NetworkVariableEquality<long>.ValueEquals;
+            NetworkVariableSerialization<ulong>.Serializer = new UlongSerializer();
+            NetworkVariableSerialization<ulong>.AreEqual = NetworkVariableEquality<ulong>.ValueEquals;
+
+            // DANGO-EXP TODO: Determine if this is distributed authority only and impacts of this in client-server
+            NetworkVariableSerialization<short>.Type = CollectionItemType.Short;
+            NetworkVariableSerialization<ushort>.Type = CollectionItemType.UShort;
+            NetworkVariableSerialization<int>.Type = CollectionItemType.Int;
+            NetworkVariableSerialization<uint>.Type = CollectionItemType.UInt;
+            NetworkVariableSerialization<long>.Type = CollectionItemType.Long;
+            NetworkVariableSerialization<ulong>.Type = CollectionItemType.ULong;
+        }
+
+        /// <summary>
+        /// Registeres an unmanaged type that will be serialized by a direct memcpy into a buffer
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedByMemcpy<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<T>.Serializer = new UnmanagedTypeSerializer<T>();
+            // DANGO-EXP TODO: Determine if this is distributed authority only and impacts of this in client-server
+            NetworkVariableSerialization<T>.Type = CollectionItemType.Unmanaged;
+        }
+
+        /// <summary>
+        /// Registeres an unmanaged type that will be serialized by a direct memcpy into a buffer
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedByMemcpyArray<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeArray<T>>.Serializer = new UnmanagedArraySerializer<T>();
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registeres an unmanaged type that will be serialized by a direct memcpy into a buffer
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedByMemcpyList<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeList<T>>.Serializer = new UnmanagedListSerializer<T>();
+        }
+
+        /// <summary>
+        /// Registeres a native hash set (this generic implementation works with all types)
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_NativeHashSet<T>() where T : unmanaged, IEquatable<T>
+        {
+            NetworkVariableSerialization<NativeHashSet<T>>.Serializer = new NativeHashSetSerializer<T>();
+        }
+
+        /// <summary>
+        /// Registeres a native hash set (this generic implementation works with all types)
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_NativeHashMap<TKey, TVal>()
+            where TKey : unmanaged, IEquatable<TKey>
+            where TVal : unmanaged
+        {
+            NetworkVariableSerialization<NativeHashMap<TKey, TVal>>.Serializer = new NativeHashMapSerializer<TKey, TVal>();
+        }
+#endif
+
+        /// <summary>
+        /// Registeres a native hash set (this generic implementation works with all types)
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_List<T>()
+        {
+            NetworkVariableSerialization<List<T>>.Serializer = new ListSerializer<T>();
+        }
+
+        /// <summary>
+        /// Registeres a native hash set (this generic implementation works with all types)
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_HashSet<T>() where T : IEquatable<T>
+        {
+            NetworkVariableSerialization<HashSet<T>>.Serializer = new HashSetSerializer<T>();
+        }
+
+        /// <summary>
+        /// Registeres a native hash set (this generic implementation works with all types)
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_Dictionary<TKey, TVal>() where TKey : IEquatable<TKey>
+        {
+            NetworkVariableSerialization<Dictionary<TKey, TVal>>.Serializer = new DictionarySerializer<TKey, TVal>();
+        }
+
+        /// <summary>
+        /// Registers an unmanaged type that implements INetworkSerializable and will be serialized through a call to
+        /// NetworkSerialize
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedINetworkSerializable<T>() where T : unmanaged, INetworkSerializable
+        {
+            NetworkVariableSerialization<T>.Serializer = new UnmanagedNetworkSerializableSerializer<T>();
+        }
+
+        /// <summary>
+        /// Registers an unmanaged type that implements INetworkSerializable and will be serialized through a call to
+        /// NetworkSerialize
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedINetworkSerializableArray<T>() where T : unmanaged, INetworkSerializable
+        {
+            NetworkVariableSerialization<NativeArray<T>>.Serializer = new UnmanagedNetworkSerializableArraySerializer<T>();
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers an unmanaged type that implements INetworkSerializable and will be serialized through a call to
+        /// NetworkSerialize
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_UnmanagedINetworkSerializableList<T>() where T : unmanaged, INetworkSerializable
+        {
+            NetworkVariableSerialization<NativeList<T>>.Serializer = new UnmanagedNetworkSerializableListSerializer<T>();
+        }
+#endif
+
+        /// <summary>
+        /// Registers a managed type that implements INetworkSerializable and will be serialized through a call to
+        /// NetworkSerialize
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_ManagedINetworkSerializable<T>() where T : class, INetworkSerializable, new()
+        {
+            NetworkVariableSerialization<T>.Serializer = new ManagedNetworkSerializableSerializer<T>();
+        }
+
+        /// <summary>
+        /// Registers a FixedString type that will be serialized through FastBufferReader/FastBufferWriter's FixedString
+        /// serializers
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_FixedString<T>() where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            NetworkVariableSerialization<T>.Serializer = new FixedStringSerializer<T>();
+        }
+
+        /// <summary>
+        /// Registers a FixedString type that will be serialized through FastBufferReader/FastBufferWriter's FixedString
+        /// serializers
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_FixedStringArray<T>() where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            NetworkVariableSerialization<NativeArray<T>>.Serializer = new FixedStringArraySerializer<T>();
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers a FixedString type that will be serialized through FastBufferReader/FastBufferWriter's FixedString
+        /// serializers
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeSerializer_FixedStringList<T>() where T : unmanaged, INativeList<byte>, IUTF8Bytes
+        {
+            NetworkVariableSerialization<NativeList<T>>.Serializer = new FixedStringListSerializer<T>();
+        }
+#endif
+
+        /// <summary>
+        /// Registers a managed type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_ManagedIEquatable<T>() where T : class, IEquatable<T>
+        {
+            NetworkVariableSerialization<T>.AreEqual = NetworkVariableEquality<T>.EqualityEqualsObject;
+        }
+
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedIEquatable<T>() where T : unmanaged, IEquatable<T>
+        {
+            NetworkVariableSerialization<T>.AreEqual = NetworkVariableEquality<T>.EqualityEquals;
+        }
+
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedIEquatableArray<T>() where T : unmanaged, IEquatable<T>
+        {
+            NetworkVariableSerialization<NativeArray<T>>.AreEqual = NetworkVariableEquality<T>.EqualityEqualsArray;
+        }
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_List<T>()
+        {
+            NetworkVariableSerialization<List<T>>.AreEqual = NetworkVariableEquality<T>.EqualityEqualsList;
+        }
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_HashSet<T>() where T : IEquatable<T>
+        {
+            NetworkVariableSerialization<HashSet<T>>.AreEqual = NetworkVariableEquality<T>.EqualityEqualsHashSet;
+        }
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_Dictionary<TKey, TVal>()
+            where TKey : IEquatable<TKey>
+        {
+            NetworkVariableSerialization<Dictionary<TKey, TVal>>.AreEqual = NetworkVariableDictionarySerialization<TKey, TVal>.GenericEqualsDictionary;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedIEquatableList<T>() where T : unmanaged, IEquatable<T>
+        {
+            NetworkVariableSerialization<NativeList<T>>.AreEqual = NetworkVariableEquality<T>.EqualityEqualsNativeList;
+        }
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_NativeHashSet<T>() where T : unmanaged, IEquatable<T>
+        {
+            NetworkVariableSerialization<NativeHashSet<T>>.AreEqual = NetworkVariableEquality<T>.EqualityEqualsNativeHashSet;
+        }
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using T.Equals()
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_NativeHashMap<TKey, TVal>()
+            where TKey : unmanaged, IEquatable<TKey>
+            where TVal : unmanaged
+        {
+            NetworkVariableSerialization<NativeHashMap<TKey, TVal>>.AreEqual = NetworkVariableMapSerialization<TKey, TVal>.GenericEqualsNativeHashMap;
+        }
+#endif
+
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using memcmp and only considered
+        /// equal if they are bitwise equivalent in memory
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedValueEquals<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<T>.AreEqual = NetworkVariableEquality<T>.ValueEquals;
+        }
+
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using memcmp and only considered
+        /// equal if they are bitwise equivalent in memory
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedValueEqualsArray<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeArray<T>>.AreEqual = NetworkVariableEquality<T>.ValueEqualsArray;
+        }
+
+#if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
+        /// <summary>
+        /// Registers an unmanaged type that will be checked for equality using memcmp and only considered
+        /// equal if they are bitwise equivalent in memory
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_UnmanagedValueEqualsList<T>() where T : unmanaged
+        {
+            NetworkVariableSerialization<NativeList<T>>.AreEqual = NetworkVariableEquality<T>.ValueEqualsList;
+        }
+#endif
+
+        /// <summary>
+        /// Registers a managed type that will be checked for equality using the == operator
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        public static void InitializeEqualityChecker_ManagedClassEquals<T>() where T : class
+        {
+            NetworkVariableSerialization<T>.AreEqual = NetworkVariableEquality<T>.ClassEquals;
+        }
+    }
+}

Runtime/NetworkVariable/Serialization/TypedILPPInitializers.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 65bdb3e11a9a412ab5e936a9c96a3da0
+timeCreated: 1718216842

Runtime/NetworkVariable/Serialization/TypedSerializerImplementations.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: bbfa170e9dd448bbbe381ce38d5c139d
+timeCreated: 1718216671

Runtime/NetworkVariable/Serialization/UserNetworkVariableSerialization.cs

@@ -0,0 +1,73 @@
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This class is used to register user serialization with NetworkVariables for types
+    /// that are serialized via user serialization, such as with FastBufferReader and FastBufferWriter
+    /// extension methods. Finding those methods isn't achievable efficiently at runtime, so this allows
+    /// users to tell NetworkVariable about those extension methods (or simply pass in a lambda)
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class UserNetworkVariableSerialization<T>
+    {
+        /// <summary>
+        /// The write value delegate handler definition
+        /// </summary>
+        /// <param name="writer">The <see cref="FastBufferWriter"/> to write the value of type `T`</param>
+        /// <param name="value">The value of type `T` to be written</param>
+        public delegate void WriteValueDelegate(FastBufferWriter writer, in T value);
+
+        /// <summary>
+        /// The write value delegate handler definition
+        /// </summary>
+        /// <param name="writer">The <see cref="FastBufferWriter"/> to write the value of type `T`</param>
+        /// <param name="value">The value of type `T` to be written</param>
+        public delegate void WriteDeltaDelegate(FastBufferWriter writer, in T value, in T previousValue);
+
+        /// <summary>
+        /// The read value delegate handler definition
+        /// </summary>
+        /// <param name="reader">The <see cref="FastBufferReader"/> to read the value of type `T`</param>
+        /// <param name="value">The value of type `T` to be read</param>
+        public delegate void ReadValueDelegate(FastBufferReader reader, out T value);
+
+        /// <summary>
+        /// The read value delegate handler definition
+        /// </summary>
+        /// <param name="reader">The <see cref="FastBufferReader"/> to read the value of type `T`</param>
+        /// <param name="value">The value of type `T` to be read</param>
+        public delegate void ReadDeltaDelegate(FastBufferReader reader, ref T value);
+
+        /// <summary>
+        /// The read value delegate handler definition
+        /// </summary>
+        /// <param name="reader">The <see cref="FastBufferReader"/> to read the value of type `T`</param>
+        /// <param name="value">The value of type `T` to be read</param>
+        public delegate void DuplicateValueDelegate(in T value, ref T duplicatedValue);
+
+        /// <summary>
+        /// Callback to write a value
+        /// </summary>
+        public static WriteValueDelegate WriteValue;
+
+        /// <summary>
+        /// Callback to read a value
+        /// </summary>
+        public static ReadValueDelegate ReadValue;
+
+        /// <summary>
+        /// Callback to write a delta between two values, based on computing the difference between the previous and
+        /// current values.
+        /// </summary>
+        public static WriteDeltaDelegate WriteDelta;
+
+        /// <summary>
+        /// Callback to read a delta, applying only select changes to the current value.
+        /// </summary>
+        public static ReadDeltaDelegate ReadDelta;
+
+        /// <summary>
+        /// Callback to create a duplicate of a value, used to check for dirty status.
+        /// </summary>
+        public static DuplicateValueDelegate DuplicateValue;
+    }
+}

Runtime/NetworkVariable/Serialization/UserNetworkVariableSerialization.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b295a6756640488b9824d2ec6e26ddae
+timeCreated: 1718218272

Runtime/SceneManagement/NetworkSceneManager.cs

@@ -425,7 +425,7 @@ namespace Unity.Netcode
 
         /// <summary>
         /// Returns the currently loaded scenes that are synchronized with the session owner or server depending upon the selected
-        /// NetworkManager session mode.
+        /// network topology.
         /// </summary>
         /// <remarks>
         /// The <see cref="SceneManager"/> scenes loaded returns all scenes loaded where this returns only the scenes that have been
@@ -444,6 +444,7 @@ namespace Unity.Netcode
         internal Dictionary<int, int> ServerSceneHandleToClientSceneHandle = new Dictionary<int, int>();
         internal Dictionary<int, int> ClientSceneHandleToServerSceneHandle = new Dictionary<int, int>();
 
+        internal bool IsRestoringSession;
         /// <summary>
         /// Add the client to server (and vice versa) scene handle lookup.
         /// Add the client-side handle to scene entry in the HandleToScene table.
@@ -455,7 +456,7 @@ namespace Unity.Netcode
             {
                 ServerSceneHandleToClientSceneHandle.Add(serverHandle, clientHandle);
             }
-            else
+            else if (!IsRestoringSession)
             {
                 return false;
             }
@@ -464,7 +465,7 @@ namespace Unity.Netcode
             {
                 ClientSceneHandleToServerSceneHandle.Add(clientHandle, serverHandle);
             }
-            else
+            else if (!IsRestoringSession)
             {
                 return false;
             }
@@ -1045,7 +1046,7 @@ namespace Unity.Netcode
         /// <param name="targetClientIds">array of client identifiers to receive the scene event message</param>
         private void SendSceneEventData(uint sceneEventId, ulong[] targetClientIds)
         {
-            if (targetClientIds.Length == 0)
+            if (targetClientIds.Length == 0 && !NetworkManager.DistributedAuthorityMode)
             {
                 // This would be the Host/Server with no clients connected
                 // Silently return as there is nothing to be done
@@ -1056,6 +1057,16 @@ namespace Unity.Netcode
 
             if (NetworkManager.DistributedAuthorityMode && !NetworkManager.DAHost)
             {
+                if (NetworkManager.DistributedAuthorityMode && HasSceneAuthority())
+                {
+                    sceneEvent.TargetClientId = NetworkManager.ServerClientId;
+                    var message = new SceneEventMessage
+                    {
+                        EventData = sceneEvent,
+                    };
+                    var size = NetworkManager.ConnectionManager.SendMessage(ref message, k_DeliveryType, NetworkManager.ServerClientId);
+                    NetworkManager.NetworkMetrics.TrackSceneEventSent(NetworkManager.ServerClientId, (uint)sceneEvent.SceneEventType, SceneNameFromHash(sceneEvent.SceneHash), size);
+                }
                 foreach (var clientId in targetClientIds)
                 {
                     sceneEvent.TargetClientId = clientId;
@@ -1859,6 +1870,17 @@ namespace Unity.Netcode
                 }
             }
 
+            foreach (var keyValuePairByGlobalObjectIdHash in ScenePlacedObjects)
+            {
+                foreach (var keyValuePairBySceneHandle in keyValuePairByGlobalObjectIdHash.Value)
+                {
+                    if (!keyValuePairBySceneHandle.Value.IsPlayerObject)
+                    {
+                        keyValuePairBySceneHandle.Value.InternalInSceneNetworkObjectsSpawned();
+                    }
+                }
+            }
+
             // Add any despawned when spawned in-scene placed NetworkObjects to the scene event data
             sceneEventData.AddDespawnedInSceneNetworkObjects();
 
@@ -2413,6 +2435,18 @@ namespace Unity.Netcode
                             {
                                 NetworkLog.LogInfo($"[Client-{NetworkManager.LocalClientId}][Scene Management Enabled] Synchronization complete!");
                             }
+                            // For convenience, notify all NetworkBehaviours that synchronization is complete.
+                            foreach (var networkObject in NetworkManager.SpawnManager.SpawnedObjectsList)
+                            {
+                                networkObject.InternalNetworkSessionSynchronized();
+                            }
+
+                            if (NetworkManager.DistributedAuthorityMode && HasSceneAuthority() && IsRestoringSession)
+                            {
+                                IsRestoringSession = false;
+                                PostSynchronizationSceneUnloading = m_OriginalPostSynchronizationSceneUnloading;
+                            }
+
                             EndSceneEvent(sceneEventId);
                         }
                         break;
@@ -2599,6 +2633,8 @@ namespace Unity.Netcode
         /// </summary>
         internal bool SkipSceneHandling;
 
+        private bool m_OriginalPostSynchronizationSceneUnloading;
+
         /// <summary>
         /// Both Client and Server: Incoming scene event entry point
         /// </summary>
@@ -2672,6 +2708,12 @@ namespace Unity.Netcode
                         // Only if ClientSynchronizationMode is Additive and the client receives a synchronize scene event
                         if (ClientSynchronizationMode == LoadSceneMode.Additive)
                         {
+                            if (NetworkManager.DistributedAuthorityMode && HasSceneAuthority() && IsRestoringSession && clientId == NetworkManager.ServerClientId)
+                            {
+                                m_OriginalPostSynchronizationSceneUnloading = PostSynchronizationSceneUnloading;
+                                PostSynchronizationSceneUnloading = true;
+                            }
+
                             // Check for scenes already loaded and create a table of scenes already loaded (SceneEntries) that will be
                             // used if the server is synchronizing the same scenes (i.e. if a matching scene is already loaded on the
                             // client side, then that scene will be used as opposed to loading another scene). This allows for clients

Runtime/SceneManagement/SceneEventData.cs

@@ -839,7 +839,7 @@ namespace Unity.Netcode
             {
                 // is not packed!
                 InternalBuffer.ReadValueSafe(out ushort newObjectsCount);
-
+                var sceneObjects = new List<NetworkObject>();
                 for (ushort i = 0; i < newObjectsCount; i++)
                 {
                     var sceneObject = new NetworkObject.SceneObject();
@@ -851,10 +851,22 @@ namespace Unity.Netcode
                         m_NetworkManager.SceneManager.SetTheSceneBeingSynchronized(sceneObject.NetworkSceneHandle);
                     }
 
-                    NetworkObject.AddSceneObject(sceneObject, InternalBuffer, m_NetworkManager);
+                    var networkObject = NetworkObject.AddSceneObject(sceneObject, InternalBuffer, m_NetworkManager);
+
+                    if (sceneObject.IsSceneObject)
+                    {
+                        sceneObjects.Add(networkObject);
+                    }
                 }
                 // Now deserialize the despawned in-scene placed NetworkObjects list (if any)
                 DeserializeDespawnedInScenePlacedNetworkObjects();
+
+                // Notify all newly spawned in-scene placed NetworkObjects that all in-scene placed
+                // NetworkObjects have been spawned.
+                foreach (var networkObject in sceneObjects)
+                {
+                    networkObject.InternalInSceneNetworkObjectsSpawned();
+                }
             }
             finally
             {
@@ -1122,6 +1134,15 @@ namespace Unity.Netcode
                     UnityEngine.Debug.Log(builder.ToString());
                 }
 
+                // Notify that all in-scene placed NetworkObjects have been spawned
+                foreach (var networkObject in m_NetworkObjectsSync)
+                {
+                    if (networkObject.IsSceneObject.HasValue && networkObject.IsSceneObject.Value)
+                    {
+                        networkObject.InternalInSceneNetworkObjectsSpawned();
+                    }
+                }
+
                 // Now deserialize the despawned in-scene placed NetworkObjects list (if any)
                 DeserializeDespawnedInScenePlacedNetworkObjects();
 

Runtime/Serialization/FastBufferReader.cs

@@ -523,8 +523,8 @@ namespace Unity.Netcode
         /// <param name="oneByteChars">Whether or not to use one byte per character. This will only allow ASCII</param>
         public unsafe void ReadValue(out string s, bool oneByteChars = false)
         {
-            ReadValue(out uint length);
+            ReadLength(out int length);
-            s = "".PadRight((int)length);
+            s = "".PadRight(length);
             int target = s.Length;
             fixed (char* native = s)
             {
@@ -562,18 +562,18 @@ namespace Unity.Netcode
             }
 #endif
 
-            if (!TryBeginReadInternal(sizeof(uint)))
+            if (!TryBeginReadInternal(SizeOfLengthField()))
             {
                 throw new OverflowException("Reading past the end of the buffer");
             }
 
-            ReadValue(out uint length);
+            ReadLength(out int length);
 
-            if (!TryBeginReadInternal((int)length * (oneByteChars ? 1 : sizeof(char))))
+            if (!TryBeginReadInternal(length * (oneByteChars ? 1 : sizeof(char))))
             {
                 throw new OverflowException("Reading past the end of the buffer");
             }
-            s = "".PadRight((int)length);
+            s = "".PadRight(length);
             int target = s.Length;
             fixed (char* native = s)
             {
@@ -592,6 +592,33 @@ namespace Unity.Netcode
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int SizeOfLengthField() => sizeof(uint);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void ReadLengthSafe(out uint length) => ReadUnmanagedSafe(out length);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void ReadLength(out uint length) => ReadUnmanaged(out length);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void ReadLengthSafe(out int length)
+        {
+            ReadLengthSafe(out uint temp);
+            if (temp > int.MaxValue)
+            {
+                throw new InvalidCastException("length value outside of int32 range");
+            }
+            length = (int)temp;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void ReadLength(out int length)
+        {
+            ReadLength(out uint temp);
+            length = (int)temp;
+        }
+
         /// <summary>
         /// Read a partial value. The value is zero-initialized and then the specified number of bytes is read into it.
         /// </summary>
@@ -777,7 +804,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void ReadUnmanaged<T>(out T[] value) where T : unmanaged
         {
-            ReadUnmanaged(out int sizeInTs);
+            ReadLength(out int sizeInTs);
             int sizeInBytes = sizeInTs * sizeof(T);
             value = new T[sizeInTs];
             fixed (T* ptr = value)
@@ -789,7 +816,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void ReadUnmanagedSafe<T>(out T[] value) where T : unmanaged
         {
-            ReadUnmanagedSafe(out int sizeInTs);
+            ReadLengthSafe(out int sizeInTs);
             int sizeInBytes = sizeInTs * sizeof(T);
             value = new T[sizeInTs];
             fixed (T* ptr = value)
@@ -801,7 +828,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void ReadUnmanaged<T>(out NativeArray<T> value, Allocator allocator) where T : unmanaged
         {
-            ReadUnmanaged(out int sizeInTs);
+            ReadLength(out int sizeInTs);
             int sizeInBytes = sizeInTs * sizeof(T);
             value = new NativeArray<T>(sizeInTs, allocator);
             byte* bytes = (byte*)value.GetUnsafePtr();
@@ -810,7 +837,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void ReadUnmanagedSafe<T>(out NativeArray<T> value, Allocator allocator) where T : unmanaged
         {
-            ReadUnmanagedSafe(out int sizeInTs);
+            ReadLengthSafe(out int sizeInTs);
             int sizeInBytes = sizeInTs * sizeof(T);
             value = new NativeArray<T>(sizeInTs, allocator);
             byte* bytes = (byte*)value.GetUnsafePtr();
@@ -820,7 +847,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void ReadUnmanagedInPlace<T>(ref NativeList<T> value) where T : unmanaged
         {
-            ReadUnmanaged(out int sizeInTs);
+            ReadLength(out int sizeInTs);
             int sizeInBytes = sizeInTs * sizeof(T);
             value.Resize(sizeInTs, NativeArrayOptions.UninitializedMemory);
             byte* bytes = (byte*)value.GetUnsafePtr();
@@ -829,7 +856,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void ReadUnmanagedSafeInPlace<T>(ref NativeList<T> value) where T : unmanaged
         {
-            ReadUnmanagedSafe(out int sizeInTs);
+            ReadLengthSafe(out int sizeInTs);
             int sizeInBytes = sizeInTs * sizeof(T);
             value.Resize(sizeInTs, NativeArrayOptions.UninitializedMemory);
             byte* bytes = (byte*)value.GetUnsafePtr();
@@ -1078,7 +1105,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal void ReadValueSafeInPlace<T>(ref NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
         {
-            ReadUnmanagedSafe(out int length);
+            ReadLengthSafe(out int length);
             value.Clear();
             for (var i = 0; i < length; ++i)
             {
@@ -1093,7 +1120,7 @@ namespace Unity.Netcode
             where TKey : unmanaged, IEquatable<TKey>
             where TVal : unmanaged
         {
-            ReadUnmanagedSafe(out int length);
+            ReadLengthSafe(out int length);
             value.Clear();
             for (var i = 0; i < length; ++i)
             {
@@ -1553,7 +1580,7 @@ namespace Unity.Netcode
         /// This method is a little difficult to use, since you have to know the size of the string before
         /// reading it, but is useful when the string is a known, fixed size. Note that the size of the
         /// string is also encoded, so the size to call TryBeginRead on is actually the fixed size (in bytes)
-        /// plus sizeof(int)
+        /// plus sizeof(uint)
         /// </summary>
         /// <param name="value">the value to read</param>
         /// <param name="unused">An unused parameter used for enabling overload resolution based on generic constraints</param>
@@ -1562,7 +1589,7 @@ namespace Unity.Netcode
         public unsafe void ReadValue<T>(out T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            ReadUnmanaged(out int length);
+            ReadLength(out int length);
             value = new T
             {
                 Length = length
@@ -1584,7 +1611,7 @@ namespace Unity.Netcode
         public unsafe void ReadValueSafe<T>(out T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            ReadUnmanagedSafe(out int length);
+            ReadLengthSafe(out int length);
             value = new T
             {
                 Length = length
@@ -1606,7 +1633,7 @@ namespace Unity.Netcode
         public unsafe void ReadValueSafeInPlace<T>(ref T value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            ReadUnmanagedSafe(out int length);
+            ReadLengthSafe(out int length);
             value.Length = length;
             ReadBytesSafe(value.GetUnsafePtr(), length);
         }
@@ -1625,7 +1652,7 @@ namespace Unity.Netcode
         public unsafe void ReadValueSafe<T>(out NativeArray<T> value, Allocator allocator)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            ReadUnmanagedSafe(out int length);
+            ReadLengthSafe(out int length);
             value = new NativeArray<T>(length, allocator);
             var ptr = (T*)value.GetUnsafePtr();
             for (var i = 0; i < length; ++i)
@@ -1647,7 +1674,7 @@ namespace Unity.Netcode
         public unsafe void ReadValueSafeTemp<T>(out NativeArray<T> value)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            ReadUnmanagedSafe(out int length);
+            ReadLengthSafe(out int length);
             value = new NativeArray<T>(length, Allocator.Temp);
             var ptr = (T*)value.GetUnsafePtr();
             for (var i = 0; i < length; ++i)
@@ -1669,7 +1696,7 @@ namespace Unity.Netcode
         public void ReadValueSafe<T>(out T[] value, FastBufferWriter.ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            ReadUnmanagedSafe(out int length);
+            ReadLengthSafe(out int length);
             value = new T[length];
             for (var i = 0; i < length; ++i)
             {
@@ -1691,7 +1718,7 @@ namespace Unity.Netcode
         public void ReadValueSafeInPlace<T>(ref NativeList<T> value)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            ReadUnmanagedSafe(out int length);
+            ReadLengthSafe(out int length);
             value.Resize(length, NativeArrayOptions.UninitializedMemory);
             for (var i = 0; i < length; ++i)
             {

Runtime/Serialization/FastBufferWriter.cs

@@ -421,7 +421,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static int GetWriteSize(string s, bool oneByteChars = false)
         {
-            return sizeof(int) + s.Length * (oneByteChars ? sizeof(byte) : sizeof(char));
+            return SizeOfLengthField() + s.Length * (oneByteChars ? sizeof(byte) : sizeof(char));
         }
 
         /// <summary>
@@ -445,7 +445,7 @@ namespace Unity.Netcode
         public void WriteNetworkSerializable<T>(T[] array, int count = -1, int offset = 0) where T : INetworkSerializable
         {
             int sizeInTs = count != -1 ? count : array.Length - offset;
-            WriteValueSafe(sizeInTs);
+            WriteLengthSafe(sizeInTs);
             foreach (var item in array)
             {
                 WriteNetworkSerializable(item);
@@ -462,7 +462,7 @@ namespace Unity.Netcode
         public void WriteNetworkSerializable<T>(NativeArray<T> array, int count = -1, int offset = 0) where T : unmanaged, INetworkSerializable
         {
             int sizeInTs = count != -1 ? count : array.Length - offset;
-            WriteValueSafe(sizeInTs);
+            WriteLengthSafe(sizeInTs);
             foreach (var item in array)
             {
                 WriteNetworkSerializable(item);
@@ -480,7 +480,7 @@ namespace Unity.Netcode
         public void WriteNetworkSerializable<T>(NativeList<T> array, int count = -1, int offset = 0) where T : unmanaged, INetworkSerializable
         {
             int sizeInTs = count != -1 ? count : array.Length - offset;
-            WriteValueSafe(sizeInTs);
+            WriteLengthSafe(sizeInTs);
             foreach (var item in array)
             {
                 WriteNetworkSerializable(item);
@@ -495,7 +495,7 @@ namespace Unity.Netcode
         /// <param name="oneByteChars">Whether or not to use one byte per character. This will only allow ASCII</param>
         public unsafe void WriteValue(string s, bool oneByteChars = false)
         {
-            WriteValue((uint)s.Length);
+            WriteLength((uint)s.Length);
             int target = s.Length;
             if (oneByteChars)
             {
@@ -538,7 +538,7 @@ namespace Unity.Netcode
                 throw new OverflowException("Writing past the end of the buffer");
             }
 
-            WriteValue((uint)s.Length);
+            WriteLength((uint)s.Length);
             int target = s.Length;
             if (oneByteChars)
             {
@@ -569,7 +569,7 @@ namespace Unity.Netcode
         {
             int sizeInTs = count != -1 ? count : array.Length - offset;
             int sizeInBytes = sizeInTs * sizeof(T);
-            return sizeof(int) + sizeInBytes;
+            return SizeOfLengthField() + sizeInBytes;
         }
 
         /// <summary>
@@ -585,7 +585,7 @@ namespace Unity.Netcode
         {
             int sizeInTs = count != -1 ? count : array.Length - offset;
             int sizeInBytes = sizeInTs * sizeof(T);
-            return sizeof(int) + sizeInBytes;
+            return SizeOfLengthField() + sizeInBytes;
         }
 
 #if UNITY_NETCODE_NATIVE_COLLECTION_SUPPORT
@@ -602,7 +602,7 @@ namespace Unity.Netcode
         {
             int sizeInTs = count != -1 ? count : array.Length - offset;
             int sizeInBytes = sizeInTs * sizeof(T);
-            return sizeof(int) + sizeInBytes;
+            return SizeOfLengthField() + sizeInBytes;
         }
 #endif
 
@@ -876,7 +876,7 @@ namespace Unity.Netcode
         public static int GetWriteSize<T>(in T value)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            return value.Length + sizeof(int);
+            return SizeOfLengthField() + value.Length;
         }
 
         /// <summary>
@@ -888,10 +888,10 @@ namespace Unity.Netcode
         public static int GetWriteSize<T>(in NativeArray<T> value)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            var size = sizeof(int);
+            var size = SizeOfLengthField();
             foreach (var item in value)
             {
-                size += sizeof(int) + item.Length;
+                size += SizeOfLengthField() + item.Length;
             }
 
             return size;
@@ -907,10 +907,10 @@ namespace Unity.Netcode
         public static int GetWriteSize<T>(in NativeList<T> value)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            var size = sizeof(int);
+            var size = SizeOfLengthField();
             foreach (var item in value)
             {
-                size += sizeof(int) + item.Length;
+                size += SizeOfLengthField() + item.Length;
             }
 
             return size;
@@ -946,10 +946,32 @@ namespace Unity.Netcode
             }
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static int SizeOfLengthField() => sizeof(uint);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void WriteLengthSafe(uint length) => WriteUnmanagedSafe(length);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void WriteLength(uint length) => WriteUnmanaged(length);
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void WriteLengthSafe(int length)
+        {
+            if (length < 0)
+            {
+                throw new InvalidCastException("Cannot write negative length");
+            }
+            WriteLengthSafe((uint)length);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private void WriteLength(int length) => WriteLength((uint)length);
+
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void WriteUnmanaged<T>(T[] value) where T : unmanaged
         {
-            WriteUnmanaged(value.Length);
+            WriteLength(value.Length);
             fixed (T* ptr = value)
             {
                 byte* bytes = (byte*)ptr;
@@ -959,7 +981,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void WriteUnmanagedSafe<T>(T[] value) where T : unmanaged
         {
-            WriteUnmanagedSafe(value.Length);
+            WriteLengthSafe(value.Length);
             fixed (T* ptr = value)
             {
                 byte* bytes = (byte*)ptr;
@@ -970,7 +992,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void WriteUnmanaged<T>(NativeArray<T> value) where T : unmanaged
         {
-            WriteUnmanaged(value.Length);
+            WriteLength(value.Length);
             var ptr = (T*)value.GetUnsafePtr();
             {
                 byte* bytes = (byte*)ptr;
@@ -980,7 +1002,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void WriteUnmanagedSafe<T>(NativeArray<T> value) where T : unmanaged
         {
-            WriteUnmanagedSafe(value.Length);
+            WriteLengthSafe(value.Length);
             var ptr = (T*)value.GetUnsafePtr();
             {
                 byte* bytes = (byte*)ptr;
@@ -992,7 +1014,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void WriteUnmanaged<T>(NativeList<T> value) where T : unmanaged
         {
-            WriteUnmanaged(value.Length);
+            WriteLength(value.Length);
 #if UTP_TRANSPORT_2_0_ABOVE
             var ptr = value.GetUnsafePtr();
 #else
@@ -1006,7 +1028,7 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal unsafe void WriteUnmanagedSafe<T>(NativeList<T> value) where T : unmanaged
         {
-            WriteUnmanagedSafe(value.Length);
+            WriteLengthSafe(value.Length);
 #if UTP_TRANSPORT_2_0_ABOVE
             var ptr = value.GetUnsafePtr();
 #else
@@ -1210,9 +1232,9 @@ namespace Unity.Netcode
         internal void WriteValueSafe<T>(NativeHashSet<T> value) where T : unmanaged, IEquatable<T>
         {
 #if UTP_TRANSPORT_2_0_ABOVE
-            WriteUnmanagedSafe(value.Count);
+            WriteLengthSafe(value.Count);
 #else
-            WriteUnmanagedSafe(value.Count());
+            WriteLengthSafe(value.Count());
 #endif
             foreach (var item in value)
             {
@@ -1227,9 +1249,9 @@ namespace Unity.Netcode
             where TVal : unmanaged
         {
 #if UTP_TRANSPORT_2_0_ABOVE
-            WriteUnmanagedSafe(value.Count);
+            WriteLengthSafe(value.Count);
 #else
-            WriteUnmanagedSafe(value.Count());
+            WriteLengthSafe(value.Count());
 #endif
             foreach (var item in value)
             {
@@ -1765,7 +1787,8 @@ namespace Unity.Netcode
         public unsafe void WriteValue<T>(in T value, ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            WriteUnmanaged(value.Length);
+            // BytePacker.WriteValuePacked(this, value.Length);
+            WriteLength(value.Length);
             // This avoids a copy on the string, which could be costly for FixedString4096Bytes
             // Otherwise, GetUnsafePtr() is an impure function call and will result in a copy
             // for `in` parameters.
@@ -1787,7 +1810,7 @@ namespace Unity.Netcode
         public void WriteValue<T>(T[] value, ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            WriteUnmanaged(value.Length);
+            WriteLength(value.Length);
             foreach (var str in value)
             {
                 WriteValue(str);
@@ -1806,7 +1829,7 @@ namespace Unity.Netcode
         public void WriteValue<T>(in NativeArray<T> value, ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            WriteUnmanaged(value.Length);
+            WriteLength(value.Length);
             foreach (var str in value)
             {
                 WriteValue(str);
@@ -1826,7 +1849,7 @@ namespace Unity.Netcode
         public void WriteValue<T>(in NativeList<T> value, ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            WriteUnmanaged(value.Length);
+            WriteLength(value.Length);
             foreach (var str in value)
             {
                 WriteValue(str);
@@ -1848,7 +1871,7 @@ namespace Unity.Netcode
         public void WriteValueSafe<T>(in T value, ForFixedStrings unused = default)
             where T : unmanaged, INativeList<byte>, IUTF8Bytes
         {
-            if (!TryBeginWriteInternal(sizeof(int) + value.Length))
+            if (!TryBeginWriteInternal(SizeOfLengthField() + value.Length))
             {
                 throw new OverflowException("Writing past the end of the buffer");
             }
@@ -1871,7 +1894,7 @@ namespace Unity.Netcode
             {
                 throw new OverflowException("Writing past the end of the buffer");
             }
-            WriteUnmanaged(value.Length);
+            WriteLength(value.Length);
             foreach (var str in value)
             {
                 WriteValue(str);
@@ -1894,7 +1917,7 @@ namespace Unity.Netcode
             {
                 throw new OverflowException("Writing past the end of the buffer");
             }
-            WriteUnmanaged(value.Length);
+            WriteLength(value.Length);
             foreach (var str in value)
             {
                 WriteValue(str);
@@ -1918,7 +1941,7 @@ namespace Unity.Netcode
             {
                 throw new OverflowException("Writing past the end of the buffer");
             }
-            WriteUnmanaged(value.Length);
+            WriteLength(value.Length);
             foreach (var str in value)
             {
                 WriteValue(str);

Runtime/Serialization/NetworkBehaviourReference.cs

@@ -11,6 +11,8 @@ namespace Unity.Netcode
     {
         private NetworkObjectReference m_NetworkObjectReference;
         private ushort m_NetworkBehaviourId;
+        private static ushort s_NullId = ushort.MaxValue;
+
 
         /// <summary>
         /// Creates a new instance of the <see cref="NetworkBehaviourReference{T}"/> struct.
@@ -21,7 +23,9 @@ namespace Unity.Netcode
         {
             if (networkBehaviour == null)
             {
-                throw new ArgumentNullException(nameof(networkBehaviour));
+                m_NetworkObjectReference = new NetworkObjectReference((NetworkObject)null);
+                m_NetworkBehaviourId = s_NullId;
+                return;
             }
             if (networkBehaviour.NetworkObject == null)
             {
@@ -60,6 +64,11 @@ namespace Unity.Netcode
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static NetworkBehaviour GetInternal(NetworkBehaviourReference networkBehaviourRef, NetworkManager networkManager = null)
         {
+            if (networkBehaviourRef.m_NetworkBehaviourId == s_NullId)
+            {
+                return null;
+            }
+
             if (networkBehaviourRef.m_NetworkObjectReference.TryGet(out NetworkObject networkObject, networkManager))
             {
                 return networkObject.GetNetworkBehaviourAtOrderIndex(networkBehaviourRef.m_NetworkBehaviourId);

Runtime/Serialization/NetworkObjectReference.cs

@@ -10,6 +10,7 @@ namespace Unity.Netcode
     public struct NetworkObjectReference : INetworkSerializable, IEquatable<NetworkObjectReference>
     {
         private ulong m_NetworkObjectId;
+        private static ulong s_NullId = ulong.MaxValue;
 
         /// <summary>
         /// The <see cref="NetworkObject.NetworkObjectId"/> of the referenced <see cref="NetworkObject"/>.
@@ -30,7 +31,8 @@ namespace Unity.Netcode
         {
             if (networkObject == null)
             {
-                throw new ArgumentNullException(nameof(networkObject));
+                m_NetworkObjectId = s_NullId;
+                return;
             }
 
             if (networkObject.IsSpawned == false)
@@ -51,10 +53,16 @@ namespace Unity.Netcode
         {
             if (gameObject == null)
             {
-                throw new ArgumentNullException(nameof(gameObject));
+                m_NetworkObjectId = s_NullId;
+                return;
+            }
+
+            var networkObject = gameObject.GetComponent<NetworkObject>();
+            if (!networkObject)
+            {
+                throw new ArgumentException($"Cannot create {nameof(NetworkObjectReference)} from {nameof(GameObject)} without a {nameof(NetworkObject)} component.");
             }
 
-            var networkObject = gameObject.GetComponent<NetworkObject>() ?? 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.");
@@ -80,10 +88,14 @@ namespace Unity.Netcode
         /// </summary>
         /// <param name="networkObjectRef">The reference.</param>
         /// <param name="networkManager">The networkmanager. Uses <see cref="NetworkManager.Singleton"/> to resolve if null.</param>
-        /// <returns>The resolves <see cref="NetworkObject"/>. Returns null if the networkobject was not found</returns>
+        /// <returns>The resolved <see cref="NetworkObject"/>. Returns null if the networkobject was not found</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static NetworkObject Resolve(NetworkObjectReference networkObjectRef, NetworkManager networkManager = null)
         {
+            if (networkObjectRef.m_NetworkObjectId == s_NullId)
+            {
+                return null;
+            }
             networkManager = networkManager ?? NetworkManager.Singleton;
             networkManager.SpawnManager.SpawnedObjects.TryGetValue(networkObjectRef.m_NetworkObjectId, out NetworkObject networkObject);
 

Runtime/Spawning/NetworkSpawnManager.cs

@@ -275,17 +275,17 @@ namespace Unity.Netcode
         }
 
         /// <summary>
-        /// Returns a list of all NetworkObjects that belong to a client.
+        /// Returns an array of all NetworkObjects that belong to a client.
         /// </summary>
-        /// <param name="clientId">the client's id  <see cref="NetworkManager.LocalClientId"/></param>
+        /// <param name="clientId">the client's id <see cref="NetworkManager.LocalClientId"/></param>
-        /// <returns>returns the list of <see cref="NetworkObject"/>s owned by the client</returns>
+        /// <returns>returns an array of the <see cref="NetworkObject"/>s owned by the client</returns>
-        public List<NetworkObject> GetClientOwnedObjects(ulong clientId)
+        public NetworkObject[] GetClientOwnedObjects(ulong clientId)
         {
             if (!OwnershipToObjectsTable.ContainsKey(clientId))
             {
                 OwnershipToObjectsTable.Add(clientId, new Dictionary<ulong, NetworkObject>());
             }
-            return OwnershipToObjectsTable[clientId].Values.ToList();
+            return OwnershipToObjectsTable[clientId].Values.ToArray();
         }
 
         /// <summary>
@@ -810,20 +810,27 @@ namespace Unity.Netcode
                 networkObject.DontDestroyWithOwner = sceneObject.DontDestroyWithOwner;
                 networkObject.Ownership = (NetworkObject.OwnershipStatus)sceneObject.OwnershipFlags;
 
+
+                var nonNetworkObjectParent = false;
                 // 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
                 // synchronization information does not indicate the NetworkObject in question has a parent.
                 // Under this scenario, we want to remove the parent before spawning and setting the transform values.
-                if (sceneObject.IsSceneObject && !sceneObject.HasParent && networkObject.transform.parent != null)
+                if (sceneObject.IsSceneObject && networkObject.transform.parent != null)
                 {
+                    var parentNetworkObject = networkObject.transform.parent.GetComponent<NetworkObject>();
                     // if the in-scene placed NetworkObject has a parent NetworkObject but the synchronization information does not
                     // include parenting, then we need to force the removal of that parent
-                    if (networkObject.transform.parent.GetComponent<NetworkObject>() != null)
+                    if (!sceneObject.HasParent && parentNetworkObject)
                     {
                         // remove the parent
                         networkObject.ApplyNetworkParenting(true, true);
                     }
+                    else if (sceneObject.HasParent && !parentNetworkObject)
+                    {
+                        nonNetworkObjectParent = true;
+                    }
                 }
 
                 // Set the transform unless we were spawned by a prefab handler
@@ -833,7 +840,7 @@ namespace Unity.Netcode
                 {
                     // If world position stays is true or we have auto object parent synchronization disabled
                     // then we want to apply the position and rotation values world space relative
-                    if (worldPositionStays || !networkObject.AutoObjectParentSync)
+                    if ((worldPositionStays && !nonNetworkObjectParent) || !networkObject.AutoObjectParentSync)
                     {
                         networkObject.transform.position = position;
                         networkObject.transform.rotation = rotation;
@@ -917,6 +924,8 @@ namespace Unity.Netcode
                     Debug.LogError("Spawning NetworkObjects with nested NetworkObjects is only supported for scene objects. Child NetworkObjects will not be spawned over the network!");
                 }
             }
+            // Invoke NetworkBehaviour.OnPreSpawn methods
+            networkObject.InvokeBehaviourNetworkPreSpawn();
 
             // DANGO-TODO: It would be nice to allow users to specify which clients are observers prior to spawning
             // For now, this is the best place I could find to add all connected clients as observers for newly
@@ -957,12 +966,18 @@ namespace Unity.Netcode
                 }
             }
             SpawnNetworkObjectLocallyCommon(networkObject, networkId, sceneObject, playerObject, ownerClientId, destroyWithScene);
+
+            // Invoke NetworkBehaviour.OnPostSpawn methods
+            networkObject.InvokeBehaviourNetworkPostSpawn();
         }
 
         /// <summary>
         /// This is only invoked to instantiate a serialized NetworkObject via
         /// <see cref="NetworkObject.AddSceneObject(in NetworkObject.SceneObject, FastBufferReader, NetworkManager, bool)"/>
         /// </summary>
+        /// <remarks>
+        /// IMPORTANT: Pre spawn methods need to be invoked from within <see cref="NetworkObject.AddSceneObject"/>.
+        /// </remarks>
         internal void SpawnNetworkObjectLocally(NetworkObject networkObject, in NetworkObject.SceneObject sceneObject, bool destroyWithScene)
         {
             if (networkObject == null)
@@ -975,7 +990,11 @@ namespace Unity.Netcode
                 throw new SpawnStateException($"[{networkObject.name}] Object-{networkObject.NetworkObjectId} is already spawned!");
             }
 
+            // Do not invoke Pre spawn here (SynchronizeNetworkBehaviours needs to be invoked prior to this)
             SpawnNetworkObjectLocallyCommon(networkObject, sceneObject.NetworkObjectId, sceneObject.IsSceneObject, sceneObject.IsPlayerObject, sceneObject.OwnerClientId, destroyWithScene);
+
+            // It is ok to invoke NetworkBehaviour.OnPostSpawn methods
+            networkObject.InvokeBehaviourNetworkPostSpawn();
         }
 
         private void SpawnNetworkObjectLocallyCommon(NetworkObject networkObject, ulong networkId, bool sceneObject, bool playerObject, ulong ownerClientId, bool destroyWithScene)
@@ -1226,7 +1245,7 @@ namespace Unity.Netcode
                     {
                         // If it is an in-scene placed NetworkObject then just despawn and let it be destroyed when the scene
                         // is unloaded. Otherwise, despawn and destroy it.
-                        var shouldDestroy = !(networkObjects[i].IsSceneObject != null && networkObjects[i].IsSceneObject.Value);
+                        var shouldDestroy = !(networkObjects[i].IsSceneObject == null || (networkObjects[i].IsSceneObject != null && networkObjects[i].IsSceneObject.Value));
 
                         // If we are going to destroy this NetworkObject, check for any in-scene placed children that need to be removed
                         if (shouldDestroy)
@@ -1307,6 +1326,7 @@ namespace Unity.Netcode
             var networkObjects = UnityEngine.Object.FindObjectsOfType<NetworkObject>();
 #endif
             var isConnectedCMBService = NetworkManager.CMBServiceConnection;
+            var networkObjectsToSpawn = new List<NetworkObject>();
             for (int i = 0; i < networkObjects.Length; i++)
             {
                 if (networkObjects[i].NetworkManager == NetworkManager)
@@ -1323,9 +1343,17 @@ namespace Unity.Netcode
                         }
 
                         SpawnNetworkObjectLocally(networkObjects[i], GetNetworkObjectId(), true, false, ownerId, true);
+                        networkObjectsToSpawn.Add(networkObjects[i]);
                     }
                 }
             }
+
+            // Notify all in-scene placed NetworkObjects have been spawned
+            foreach (var networkObject in networkObjectsToSpawn)
+            {
+                networkObject.InternalInSceneNetworkObjectsSpawned();
+            }
+            networkObjectsToSpawn.Clear();
         }
 
         internal void OnDespawnObject(NetworkObject networkObject, bool destroyGameObject, bool modeDestroy = false)

Runtime/Timing/AnticipationSystem.cs

@@ -0,0 +1,100 @@
+using System.Collections.Generic;
+
+namespace Unity.Netcode
+{
+    internal interface IAnticipationEventReceiver
+    {
+        public void SetupForUpdate();
+        public void SetupForRender();
+    }
+
+    internal interface IAnticipatedObject
+    {
+        public void Update();
+        public void ResetAnticipation();
+        public NetworkObject OwnerObject { get; }
+    }
+
+    internal class AnticipationSystem
+    {
+        internal ulong LastAnticipationAck;
+        internal double LastAnticipationAckTime;
+
+        internal HashSet<IAnticipatedObject> AllAnticipatedObjects = new HashSet<IAnticipatedObject>();
+
+        internal ulong AnticipationCounter;
+
+        private NetworkManager m_NetworkManager;
+
+        public HashSet<IAnticipatedObject> ObjectsToReanticipate = new HashSet<IAnticipatedObject>();
+
+        public AnticipationSystem(NetworkManager manager)
+        {
+            m_NetworkManager = manager;
+        }
+
+        public event NetworkManager.ReanticipateDelegate OnReanticipate;
+
+        private HashSet<IAnticipationEventReceiver> m_AnticipationEventReceivers = new HashSet<IAnticipationEventReceiver>();
+
+        public void RegisterForAnticipationEvents(IAnticipationEventReceiver receiver)
+        {
+            m_AnticipationEventReceivers.Add(receiver);
+        }
+        public void DeregisterForAnticipationEvents(IAnticipationEventReceiver receiver)
+        {
+            m_AnticipationEventReceivers.Remove(receiver);
+        }
+
+        public void SetupForUpdate()
+        {
+            foreach (var receiver in m_AnticipationEventReceivers)
+            {
+                receiver.SetupForUpdate();
+            }
+        }
+
+        public void SetupForRender()
+        {
+            foreach (var receiver in m_AnticipationEventReceivers)
+            {
+                receiver.SetupForRender();
+            }
+        }
+
+        public void ProcessReanticipation()
+        {
+            var lastRoundTripTime = m_NetworkManager.LocalTime.Time - LastAnticipationAckTime;
+            foreach (var item in ObjectsToReanticipate)
+            {
+                foreach (var behaviour in item.OwnerObject.ChildNetworkBehaviours)
+                {
+                    behaviour.OnReanticipate(lastRoundTripTime);
+                }
+                item.ResetAnticipation();
+            }
+
+            ObjectsToReanticipate.Clear();
+            OnReanticipate?.Invoke(lastRoundTripTime);
+        }
+
+        public void Update()
+        {
+            foreach (var item in AllAnticipatedObjects)
+            {
+                item.Update();
+            }
+        }
+
+        public void Sync()
+        {
+            if (AllAnticipatedObjects.Count != 0 && !m_NetworkManager.ShutdownInProgress && !m_NetworkManager.ConnectionManager.LocalClient.IsServer && m_NetworkManager.ConnectionManager.LocalClient.IsConnected)
+            {
+                var message = new AnticipationCounterSyncPingMessage { Counter = AnticipationCounter, Time = m_NetworkManager.LocalTime.Time };
+                m_NetworkManager.MessageManager.SendMessage(ref message, NetworkDelivery.Reliable, NetworkManager.ServerClientId);
+            }
+
+            ++AnticipationCounter;
+        }
+    }
+}

Runtime/Timing/AnticipationSystem.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4a75eccede7ecf1408f61dd55c338e06

Runtime/Timing/NetworkTime.cs

@@ -24,6 +24,11 @@ namespace Unity.Netcode
         /// </summary>
         public double TickOffset => m_CachedTickOffset;
 
+        /// <summary>
+        /// Gets the tick, including partial tick value passed since it started.
+        /// </summary>
+        public double TickWithPartial => Tick + (TickOffset / m_TickInterval);
+
         /// <summary>
         /// Gets the current time. This is a non fixed time value and similar to <see cref="Time.time"/>.
         /// </summary>

Runtime/Timing/NetworkTimeSystem.cs

@@ -5,7 +5,9 @@ namespace Unity.Netcode
 {
     /// <summary>
     /// <see cref="NetworkTimeSystem"/> is a standalone system which can be used to run a network time simulation.
-    /// The network time system maintains both a local and a server time. The local time is based on
+    /// The network time system maintains both a local and a server time. The local time is based on the server time
+    /// as last received from the server plus an offset based on the current RTT - in other words, it is a best-guess
+    /// effort at predicting what the server tick will be when a given network action is processed on the server.
     /// </summary>
     public class NetworkTimeSystem
     {

Runtime/Transports/NetworkTransport.cs

@@ -106,6 +106,22 @@ namespace Unity.Netcode
         /// </summary>
         /// /// <param name="networkManager">optionally pass in NetworkManager</param>
         public abstract void Initialize(NetworkManager networkManager = null);
+
+        protected virtual NetworkTopologyTypes OnCurrentTopology()
+        {
+            return NetworkTopologyTypes.ClientServer;
+        }
+
+        internal NetworkTopologyTypes CurrentTopology()
+        {
+            return OnCurrentTopology();
+        }
+    }
+
+    public enum NetworkTopologyTypes
+    {
+        ClientServer,
+        DistributedAuthority
     }
 
 #if UNITY_INCLUDE_TESTS

Runtime/Transports/UTP/UnityTransport.cs

@@ -426,10 +426,11 @@ namespace Unity.Netcode.Transports.UTP
         internal static event Action<int> TransportDisposed;
         internal NetworkDriver NetworkDriver => m_Driver;
 
+        protected NetworkDriver m_Driver;
+
         private PacketLossCache m_PacketLossCache = new PacketLossCache();
 
         private State m_State = State.Disconnected;
-        private NetworkDriver m_Driver;
         private NetworkSettings m_NetworkSettings;
         private ulong m_ServerClientId;
 
@@ -554,12 +555,17 @@ namespace Unity.Netcode.Transports.UTP
                 return false;
             }
 
-            var serverConnection = m_Driver.Connect(serverEndpoint);
+            var serverConnection = Connect(serverEndpoint);
             m_ServerClientId = ParseClientId(serverConnection);
 
             return true;
         }
 
+        protected virtual NetworkConnection Connect(NetworkEndpoint serverEndpoint)
+        {
+            return m_Driver.Connect(serverEndpoint);
+        }
+
         private bool ServerBindAndListen(NetworkEndpoint endPoint)
         {
             // Verify the endpoint is valid before proceeding
@@ -1471,6 +1477,11 @@ namespace Unity.Netcode.Transports.UTP
         }
 #endif
 
+        protected override NetworkTopologyTypes OnCurrentTopology()
+        {
+            return NetworkManager != null ? NetworkManager.NetworkConfig.NetworkTopology : NetworkTopologyTypes.ClientServer;
+        }
+
         private string m_ServerPrivateKey;
         private string m_ServerCertificate;
 

Runtime/com.unity.netcode.runtime.asmdef

@@ -15,7 +15,13 @@
         "Unity.Burst",
         "Unity.Mathematics"
     ],
+    "includePlatforms": [],
+    "excludePlatforms": [],
     "allowUnsafeCode": true,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
     "versionDefines": [
         {
             "name": "com.unity.multiplayer.tools",
@@ -46,6 +52,27 @@
             "name": "Unity",
             "expression": "2023",
             "define": "UNITY_DEDICATED_SERVER_ARGUMENTS_PRESENT"
+        },
+        {
+            "name": "com.unity.modules.animation",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_ANIMATION"
+        },
+        {
+            "name": "com.unity.modules.physics",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_PHYSICS"
+        },
+        {
+            "name": "com.unity.modules.physics2d",
+            "expression": "",
+            "define": "COM_UNITY_MODULES_PHYSICS2D"
+        },
+        {
+            "name": "com.unity.services.multiplayer",
+            "expression": "0.2.0",
+            "define": "MULTIPLAYER_SERVICES_SDK_INSTALLED"
         }
-    ]
+    ],
-}
+    "noEngineReferences": false
+}

TestHelpers/Runtime/IntegrationTestWithApproximation.cs

@@ -87,7 +87,7 @@ namespace Unity.Netcode.TestHelpers.Runtime
             return new Vector3(Random.Range(min, max), Random.Range(min, max), Random.Range(min, max));
         }
 
-        public IntegrationTestWithApproximation(SessionModeTypes sessionModeType) : base(sessionModeType) { }
+        public IntegrationTestWithApproximation(NetworkTopologyTypes networkTopologyType) : base(networkTopologyType) { }
 
         public IntegrationTestWithApproximation(HostOrServer hostOrServer) : base(hostOrServer) { }