com.unity.netcode.gameobjects@1.3.1

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

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

## [1.3.1] - 2023-03-27

### Added

- Added detection and graceful handling of corrupt packets for additional safety. (#2419)

### Changed

- The UTP component UI has been updated to be more user-friendly for new users by adding a simple toggle to switch between local-only (127.0.0.1) and remote (0.0.0.0) binding modes, using the toggle "Allow Remote Connections" (#2408)
- Updated `UnityTransport` dependency on `com.unity.transport` to 1.3.3. (#2450)
- `NetworkShow()` of `NetworkObject`s are delayed until the end of the frame to ensure consistency of delta-driven variables like `NetworkList`.
- Dirty `NetworkObject` are reset at end-of-frame and not at serialization time.
- `NetworkHide()` of an object that was just `NetworkShow()`n produces a warning, as remote clients will _not_ get a spawn/despawn pair.
- Renamed the NetworkTransform.SetState parameter `shouldGhostsInterpolate` to `teleportDisabled` for better clarity of what that parameter does. (#2228)
- Network prefabs are now stored in a ScriptableObject that can be shared between NetworkManagers, and have been exposed for public access. By default, a Default Prefabs List is created that contains all NetworkObject prefabs in the project, and new NetworkManagers will default to using that unless that option is turned off in the Netcode for GameObjects settings. Existing NetworkManagers will maintain their existing lists, which can be migrated to the new format via a button in their inspector. (#2322)

### Fixed

- Fixed issue where changes to a layer's weight would not synchronize unless a state transition was occurring.(#2399)
- Fixed issue where `NetworkManager.LocalClientId` was returning the `NetworkTransport.ServerClientId` as opposed to the `NetworkManager.m_LocalClientId`. (#2398)
- Fixed issue where a dynamically spawned `NetworkObject` parented under an in-scene placed `NetworkObject` would have its `InScenePlaced` value changed to `true`. This would result in a soft synchronization error for late joining clients. (#2396)
- Fixed a UTP test that was failing when you install Unity Transport package 2.0.0 or newer. (#2347)
- Fixed issue where `NetcodeSettingsProvider` would throw an exception in Unity 2020.3.x versions. (#2345)
- Fixed server side issue where, depending upon component ordering, some NetworkBehaviour components might not have their OnNetworkDespawn method invoked if the client side disconnected. (#2323)
- Fixed a case where data corruption could occur when using UnityTransport when reaching a certain level of send throughput. (#2332)
- Fixed an issue in `UnityTransport` where an exception would be thrown if starting a Relay host/server on WebGL. This exception should only be thrown if using direct connections (where WebGL can't act as a host/server). (#2321)
- Fixed `NetworkAnimator` issue where it was not checking for `AnimatorStateTtansition.destinationStateMachine` and any possible sub-states defined within it. (#2309)
- Fixed `NetworkAnimator` issue where the host client was receiving the ClientRpc animation updates when the host was the owner.(#2309)
- Fixed `NetworkAnimator` issue with using pooled objects and when specific properties are cleaned during despawn and destroy.(#2309)
- Fixed issue where `NetworkAnimator` was checking for animation changes when the associated `NetworkObject` was not spawned.(#2309)
- Corrected an issue with the documentation for BufferSerializer (#2401)

Tests/Editor/Build/BuildTests.cs

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

Tests/Editor/Messaging/MessageCorruptionTests.cs

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

Tests/Editor/Messaging/MessageCorruptionTests.cs.meta

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

Tests/Editor/Messaging/MessageReceivingTests.cs

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

Tests/Editor/Messaging/MessageSendingTests.cs

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

Tests/Editor/NetworkManagerConfigurationTests.cs

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

Tests/Editor/NetworkPrefabProcessorTests.cs

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

Tests/Editor/NetworkPrefabProcessorTests.cs.meta

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

Tests/Editor/Transports/BatchedSendQueueTests.cs

@@ -229,6 +229,12 @@ namespace Unity.Netcode.EditorTests
             var writer = new DataStreamWriter(data);
             Assert.AreEqual(messageLength, q.FillWriterWithMessages(ref writer));
             AssertIsTestMessage(data);
+
+            q.Consume(messageLength);
+
+            writer = new DataStreamWriter(data);
+            Assert.AreEqual(messageLength, q.FillWriterWithMessages(ref writer));
+            AssertIsTestMessage(data);
         }
 
         [Test]

Tests/Editor/Transports/UnityTransportTests.cs

@@ -115,13 +115,29 @@ namespace Unity.Netcode.EditorTests
             UnityTransport transport = new GameObject().AddComponent<UnityTransport>();
             transport.Initialize();
 
-            transport.SetConnectionData("127.0.0.", 4242);
+            transport.SetConnectionData("127.0.0.", 4242, "127.0.0.");
             Assert.False(transport.StartServer());
 
             LogAssert.Expect(LogType.Error, "Invalid network endpoint: 127.0.0.:4242.");
-            LogAssert.Expect(LogType.Error, "Server failed to bind");
+#if UTP_TRANSPORT_2_0_ABOVE
+            LogAssert.Expect(LogType.Error, "Socket creation failed (error Unity.Baselib.LowLevel.Binding+Baselib_ErrorState: Invalid argument (0x01000003) <argument name stripped>");
+#endif
+            LogAssert.Expect(LogType.Error, "Server failed to bind. This is usually caused by another process being bound to the same port.");
 
-            transport.SetConnectionData("127.0.0.1", 4242);
+            transport.SetConnectionData("127.0.0.1", 4242, "127.0.0.1");
+            Assert.True(transport.StartServer());
+
+            transport.Shutdown();
+        }
+
+        // Check that leaving all addresses empty is valid.
+        [Test]
+        public void UnityTransport_StartServerWithoutAddresses()
+        {
+            UnityTransport transport = new GameObject().AddComponent<UnityTransport>();
+            transport.Initialize();
+
+            transport.SetConnectionData(string.Empty, 4242);
             Assert.True(transport.StartServer());
 
             transport.Shutdown();