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)
2023-03-27 00:00:00 +00:00
parent fe02ca682e
commit 8060718e04
69 changed files with 3128 additions and 888 deletions
--- a/Editor/AssemblyInfo.cs
+++ b/Editor/AssemblyInfo.cs
@@ -1,3 +1,7 @@
 using System.Runtime.CompilerServices;

+#if UNITY_INCLUDE_TESTS
+#if UNITY_EDITOR
 [assembly: InternalsVisibleTo("Unity.Netcode.EditorTests")]
+#endif // UNITY_EDITOR
+#endif // UNITY_INCLUDE_TESTS
--- a/Editor/Configuration.meta
+++ b/Editor/Configuration.meta
@@ -1,8 +1,3 @@
 fileFormatVersion: 2
-guid: 52153943c346dd04e8712ab540ab9c22
-folderAsset: yes
-DefaultImporter:
-  externalObjects: {}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 
+guid: b2f70916f7024c66aa5dfe1e43c151a2
+timeCreated: 1654274400
--- a/Editor/Configuration/NetcodeForGameObjectsSettings.cs
+++ b/Editor/Configuration/NetcodeForGameObjectsSettings.cs
@@ -1,9 +1,10 @@
 using UnityEditor;
+using UnityEngine;


 namespace Unity.Netcode.Editor.Configuration
 {
-    internal class NetcodeForGameObjectsSettings
+    internal class NetcodeForGameObjectsEditorSettings
    {
        internal const string AutoAddNetworkObjectIfNoneExists = "AutoAdd-NetworkObject-When-None-Exist";
        internal const string InstallMultiplayerToolsTipDismissedPlayerPrefKey = "Netcode_Tip_InstallMPTools_Dismissed";
@@ -14,6 +15,7 @@ namespace Unity.Netcode.Editor.Configuration
            {
                return EditorPrefs.GetInt(InstallMultiplayerToolsTipDismissedPlayerPrefKey);
            }
+
            return 0;
        }

@@ -28,6 +30,7 @@ namespace Unity.Netcode.Editor.Configuration
            {
                return EditorPrefs.GetBool(AutoAddNetworkObjectIfNoneExists);
            }
+
            return false;
        }

@@ -36,4 +39,15 @@ namespace Unity.Netcode.Editor.Configuration
            EditorPrefs.SetBool(AutoAddNetworkObjectIfNoneExists, autoAddSetting);
        }
    }
+
+    [FilePath("ProjectSettings/NetcodeForGameObjects.settings", FilePathAttribute.Location.ProjectFolder)]
+    internal class NetcodeForGameObjectsProjectSettings : ScriptableSingleton<NetcodeForGameObjectsProjectSettings>
+    {
+        [SerializeField] public bool GenerateDefaultNetworkPrefabs = true;
+
+        internal void SaveSettings()
+        {
+            Save(true);
+        }
+    }
 }
--- a/Editor/Configuration/NetcodeSettingsProvider.cs
+++ b/Editor/Configuration/NetcodeSettingsProvider.cs
@@ -5,6 +5,11 @@ namespace Unity.Netcode.Editor.Configuration
 {
    internal static class NetcodeSettingsProvider
    {
+        private const float k_MaxLabelWidth = 450f;
+        private static float s_MaxLabelWidth;
+        private static bool s_ShowEditorSettingFields = true;
+        private static bool s_ShowProjectSettingFields = true;
+
        [SettingsProvider]
        public static SettingsProvider CreateNetcodeSettingsProvider()
        {
@@ -20,25 +25,105 @@ namespace Unity.Netcode.Editor.Configuration
            return provider;
        }

-        internal static NetcodeSettingsLabel NetworkObjectsSectionLabel = new NetcodeSettingsLabel("NetworkObject Helper Settings", 20);
-        internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle = new NetcodeSettingsToggle("Auto-Add NetworkObjects", "When enabled, NetworkObjects are automatically added to GameObjects when NetworkBehaviours are added first.", 20);
-        internal static NetcodeSettingsLabel MultiplayerToolsLabel = new NetcodeSettingsLabel("Multiplayer Tools", 20);
-        internal static NetcodeSettingsToggle MultiplayerToolTipStatusToggle = new NetcodeSettingsToggle("Multiplayer Tools Install Reminder", "When enabled, the NetworkManager will display " +
-            "the notification to install the multiplayer tools package.", 20);
+
+        internal static NetcodeSettingsLabel NetworkObjectsSectionLabel;
+        internal static NetcodeSettingsToggle AutoAddNetworkObjectToggle;
+        internal static NetcodeSettingsLabel MultiplayerToolsLabel;
+        internal static NetcodeSettingsToggle MultiplayerToolTipStatusToggle;
+
+        /// <summary>
+        /// Creates an instance of the settings UI Elements if they don't already exist.
+        /// </summary>
+        /// <remarks>
+        /// We have to construct any NetcodeGUISettings derived classes here because in
+        /// version 2020.x.x EditorStyles.label does not exist yet (higher versions it does)
+        /// </remarks>
+        private static void CheckForInitialize()
+        {
+            if (NetworkObjectsSectionLabel == null)
+            {
+                NetworkObjectsSectionLabel = new NetcodeSettingsLabel("NetworkObject Helper Settings", 20);
+            }
+
+            if (AutoAddNetworkObjectToggle == null)
+            {
+                AutoAddNetworkObjectToggle = new NetcodeSettingsToggle("Auto-Add NetworkObject Component", "When enabled, NetworkObject components are automatically added to GameObjects when NetworkBehaviour components are added first.", 20);
+            }
+
+            if (MultiplayerToolsLabel == null)
+            {
+                MultiplayerToolsLabel = new NetcodeSettingsLabel("Multiplayer Tools", 20);
+            }
+
+            if (MultiplayerToolTipStatusToggle == null)
+            {
+                MultiplayerToolTipStatusToggle = new NetcodeSettingsToggle("Multiplayer Tools Install Reminder", "When enabled, the NetworkManager will display the notification to install the multiplayer tools package.", 20);
+            }
+        }

        private static void OnGuiHandler(string obj)
        {
-            var autoAddNetworkObjectSetting = NetcodeForGameObjectsSettings.GetAutoAddNetworkObjectSetting();
-            var multiplayerToolsTipStatus = NetcodeForGameObjectsSettings.GetNetcodeInstallMultiplayerToolTips() == 0;
+            // Make sure all NetcodeGUISettings derived classes are instantiated first
+            CheckForInitialize();
+
+            var autoAddNetworkObjectSetting = NetcodeForGameObjectsEditorSettings.GetAutoAddNetworkObjectSetting();
+            var multiplayerToolsTipStatus = NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() == 0;
+            var settings = NetcodeForGameObjectsProjectSettings.instance;
+            var generateDefaultPrefabs = settings.GenerateDefaultNetworkPrefabs;
+
            EditorGUI.BeginChangeCheck();
-            NetworkObjectsSectionLabel.DrawLabel();
-            autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting);
-            MultiplayerToolsLabel.DrawLabel();
-            multiplayerToolsTipStatus = MultiplayerToolTipStatusToggle.DrawToggle(multiplayerToolsTipStatus);
+
+            GUILayout.BeginVertical("Box");
+            s_ShowEditorSettingFields = EditorGUILayout.BeginFoldoutHeaderGroup(s_ShowEditorSettingFields, "Editor Settings");
+
+            if (s_ShowEditorSettingFields)
+            {
+                GUILayout.BeginVertical("Box");
+                NetworkObjectsSectionLabel.DrawLabel();
+                autoAddNetworkObjectSetting = AutoAddNetworkObjectToggle.DrawToggle(autoAddNetworkObjectSetting);
+                GUILayout.EndVertical();
+
+                GUILayout.BeginVertical("Box");
+                MultiplayerToolsLabel.DrawLabel();
+                multiplayerToolsTipStatus = MultiplayerToolTipStatusToggle.DrawToggle(multiplayerToolsTipStatus);
+                GUILayout.EndVertical();
+            }
+            EditorGUILayout.EndFoldoutHeaderGroup();
+            GUILayout.EndVertical();
+
+            GUILayout.BeginVertical("Box");
+            s_ShowProjectSettingFields = EditorGUILayout.BeginFoldoutHeaderGroup(s_ShowProjectSettingFields, "Project Settings");
+            if (s_ShowProjectSettingFields)
+            {
+                GUILayout.BeginVertical("Box");
+                const string generateNetworkPrefabsString = "Generate Default Network Prefabs List";
+
+                if (s_MaxLabelWidth == 0)
+                {
+                    s_MaxLabelWidth = EditorStyles.label.CalcSize(new GUIContent(generateNetworkPrefabsString)).x;
+                    s_MaxLabelWidth = Mathf.Min(k_MaxLabelWidth, s_MaxLabelWidth);
+                }
+
+                EditorGUIUtility.labelWidth = s_MaxLabelWidth;
+
+                GUILayout.Label("Network Prefabs", EditorStyles.boldLabel);
+                generateDefaultPrefabs = EditorGUILayout.Toggle(
+                    new GUIContent(
+                        generateNetworkPrefabsString,
+                        "When enabled, a default NetworkPrefabsList object will be added to your project and kept up " +
+                        "to date with all NetworkObject prefabs."),
+                    generateDefaultPrefabs,
+                    GUILayout.Width(s_MaxLabelWidth + 20));
+                GUILayout.EndVertical();
+            }
+            EditorGUILayout.EndFoldoutHeaderGroup();
+            GUILayout.EndVertical();
            if (EditorGUI.EndChangeCheck())
            {
-                NetcodeForGameObjectsSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting);
-                NetcodeForGameObjectsSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1);
+                NetcodeForGameObjectsEditorSettings.SetAutoAddNetworkObjectSetting(autoAddNetworkObjectSetting);
+                NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(multiplayerToolsTipStatus ? 0 : 1);
+                settings.GenerateDefaultNetworkPrefabs = generateDefaultPrefabs;
+                settings.SaveSettings();
            }
        }
    }
@@ -56,7 +141,7 @@ namespace Unity.Netcode.Editor.Configuration
        public NetcodeSettingsLabel(string labelText, float layoutOffset = 0.0f)
        {
            m_LabelContent = labelText;
-            AdjustLableSize(labelText, layoutOffset);
+            AdjustLabelSize(labelText, layoutOffset);
        }
    }

@@ -72,7 +157,7 @@ namespace Unity.Netcode.Editor.Configuration

        public NetcodeSettingsToggle(string labelText, string toolTip, float layoutOffset)
        {
-            AdjustLableSize(labelText, layoutOffset);
+            AdjustLabelSize(labelText, layoutOffset);
            m_ToggleContent = new GUIContent(labelText, toolTip);
        }
    }
@@ -84,7 +169,7 @@ namespace Unity.Netcode.Editor.Configuration

        protected GUILayoutOption m_LayoutWidth { get; private set; }

-        protected void AdjustLableSize(string labelText, float offset = 0.0f)
+        protected void AdjustLabelSize(string labelText, float offset = 0.0f)
        {
            m_LabelSize = Mathf.Min(k_MaxLabelWidth, EditorStyles.label.CalcSize(new GUIContent(labelText)).x);
            m_LayoutWidth = GUILayout.Width(m_LabelSize + offset);
--- a/Editor/Configuration/NetworkPrefabProcessor.cs
+++ b/Editor/Configuration/NetworkPrefabProcessor.cs
@@ -0,0 +1,187 @@
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor.Configuration
+{
+    /// <summary>
+    /// Updates the default <see cref="NetworkPrefabsList"/> instance when prefabs are updated (created, moved, deleted) in the project.
+    /// </summary>
+    public class NetworkPrefabProcessor : AssetPostprocessor
+    {
+        private static string s_DefaultNetworkPrefabsPath = "Assets/DefaultNetworkPrefabs.asset";
+        public static string DefaultNetworkPrefabsPath
+        {
+            get
+            {
+                return s_DefaultNetworkPrefabsPath;
+            }
+            internal set
+            {
+                s_DefaultNetworkPrefabsPath = value;
+                // Force a recache of the prefab list
+                s_PrefabsList = null;
+            }
+        }
+        private static NetworkPrefabsList s_PrefabsList;
+        private static Dictionary<string, NetworkPrefab> s_PrefabsListPath = new Dictionary<string, NetworkPrefab>();
+
+        private static void OnPostprocessAllAssets(string[] importedAssets, string[] deletedAssets, string[] movedAssets, string[] movedFromAssetPaths)
+        {
+            var settings = NetcodeForGameObjectsProjectSettings.instance;
+            if (!settings.GenerateDefaultNetworkPrefabs)
+            {
+                return;
+            }
+
+            bool ProcessImportedAssets(string[] importedAssets1)
+            {
+                var dirty = false;
+                foreach (var assetPath in importedAssets1)
+                {
+                    // We only care about GameObjects, skip everything else. Can't use the more targeted
+                    // OnPostProcessPrefabs since that's not called for moves or deletes
+                    if (AssetDatabase.GetMainAssetTypeAtPath(assetPath) != typeof(GameObject))
+                    {
+                        continue;
+                    }
+
+                    var go = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+                    if (go.TryGetComponent<NetworkObject>(out _))
+                    {
+                        // Make sure we are not duplicating an already existing entry
+                        if (s_PrefabsListPath.ContainsKey(assetPath))
+                        {
+                            // Is the imported asset different from the one we already have in the list?
+                            if (s_PrefabsListPath[assetPath].Prefab.GetHashCode() != go.GetHashCode())
+                            {
+                                // If so remove the one in the list and continue on to add the imported one
+                                s_PrefabsList.List.Remove(s_PrefabsListPath[assetPath]);
+                            }
+                            else // If they are identical, then just ignore the import
+                            {
+                                continue;
+                            }
+                        }
+
+                        s_PrefabsList.List.Add(new NetworkPrefab { Prefab = go });
+                        dirty = true;
+                    }
+                }
+
+                return dirty;
+            }
+
+            bool ProcessDeletedAssets(string[] strings)
+            {
+                var dirty = false;
+                var deleted = new List<string>(strings);
+                for (int i = s_PrefabsList.List.Count - 1; i >= 0 && deleted.Count > 0; --i)
+                {
+                    GameObject prefab;
+                    try
+                    {
+                        prefab = s_PrefabsList.List[i].Prefab;
+                    }
+                    catch (MissingReferenceException)
+                    {
+                        s_PrefabsList.List.RemoveAt(i);
+                        continue;
+                    }
+                    if (prefab == null)
+                    {
+                        s_PrefabsList.List.RemoveAt(i);
+                    }
+                    else
+                    {
+                        string noPath = AssetDatabase.GetAssetPath(prefab);
+                        for (int j = strings.Length - 1; j >= 0; --j)
+                        {
+                            if (noPath == strings[j])
+                            {
+                                s_PrefabsList.List.RemoveAt(i);
+                                deleted.RemoveAt(j);
+                                dirty = true;
+                            }
+                        }
+                    }
+                }
+
+                return dirty;
+            }
+
+            if (s_PrefabsList == null)
+            {
+                s_PrefabsList = GetOrCreateNetworkPrefabs(DefaultNetworkPrefabsPath, out var newList, true);
+                // A new list already processed all existing assets, no need to double-process imports & deletes
+                if (newList)
+                {
+                    return;
+                }
+            }
+            // Clear our asset path to prefab table each time
+            s_PrefabsListPath.Clear();
+
+            // Create our asst path to prefab table
+            foreach (var prefabEntry in s_PrefabsList.List)
+            {
+                if (!s_PrefabsListPath.ContainsKey(AssetDatabase.GetAssetPath(prefabEntry.Prefab)))
+                {
+                    s_PrefabsListPath.Add(AssetDatabase.GetAssetPath(prefabEntry.Prefab), prefabEntry);
+                }
+            }
+
+            // Process the imported and deleted assets
+            var markDirty = ProcessImportedAssets(importedAssets);
+            markDirty &= ProcessDeletedAssets(deletedAssets);
+
+            if (markDirty)
+            {
+                EditorUtility.SetDirty(s_PrefabsList);
+            }
+        }
+
+        internal static NetworkPrefabsList GetOrCreateNetworkPrefabs(string path, out bool isNew, bool addAll)
+        {
+            var defaultPrefabs = AssetDatabase.LoadAssetAtPath<NetworkPrefabsList>(path);
+            if (defaultPrefabs == null)
+            {
+                isNew = true;
+                defaultPrefabs = ScriptableObject.CreateInstance<NetworkPrefabsList>();
+                defaultPrefabs.IsDefault = true;
+                AssetDatabase.CreateAsset(defaultPrefabs, path);
+
+                if (addAll)
+                {
+                    // This could be very expensive in large projects... maybe make it manually triggered via a menu?
+                    defaultPrefabs.List = FindAll();
+                }
+                EditorUtility.SetDirty(defaultPrefabs);
+                AssetDatabase.SaveAssetIfDirty(defaultPrefabs);
+                return defaultPrefabs;
+            }
+
+            isNew = false;
+            return defaultPrefabs;
+        }
+
+        private static List<NetworkPrefab> FindAll()
+        {
+            var list = new List<NetworkPrefab>();
+
+            string[] guids = AssetDatabase.FindAssets("t:GameObject");
+            foreach (var guid in guids)
+            {
+                string assetPath = AssetDatabase.GUIDToAssetPath(guid);
+                var go = AssetDatabase.LoadAssetAtPath<GameObject>(assetPath);
+
+                if (go.TryGetComponent(out NetworkObject _))
+                {
+                    list.Add(new NetworkPrefab { Prefab = go });
+                }
+            }
+
+            return list;
+        }
+    }
+}
--- a/Editor/Configuration/NetworkPrefabProcessor.cs.meta
+++ b/Editor/Configuration/NetworkPrefabProcessor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d8b62a05d80cc444f9c74731c01b8e39
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Editor/Configuration/NetworkPrefabsEditor.cs
+++ b/Editor/Configuration/NetworkPrefabsEditor.cs
@@ -0,0 +1,97 @@
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+
+namespace Unity.Netcode.Editor
+{
+    [CustomEditor(typeof(NetworkPrefabsList), true)]
+    [CanEditMultipleObjects]
+    public class NetworkPrefabsEditor : UnityEditor.Editor
+    {
+        private ReorderableList m_NetworkPrefabsList;
+        private SerializedProperty m_IsDefaultBool;
+
+        private void OnEnable()
+        {
+            m_IsDefaultBool = serializedObject.FindProperty(nameof(NetworkPrefabsList.IsDefault));
+            m_NetworkPrefabsList = new ReorderableList(serializedObject, serializedObject.FindProperty("List"), true, true, true, true);
+            m_NetworkPrefabsList.elementHeightCallback = index =>
+            {
+                var networkOverrideInt = 0;
+                if (m_NetworkPrefabsList.count > 0)
+                {
+                    var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
+                    var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
+                    networkOverrideInt = networkOverrideProp.enumValueIndex;
+                }
+
+                return 8 + (networkOverrideInt == 0 ? EditorGUIUtility.singleLineHeight : (EditorGUIUtility.singleLineHeight * 2) + 5);
+            };
+            m_NetworkPrefabsList.drawElementCallback = (rect, index, isActive, isFocused) =>
+            {
+                rect.y += 5;
+
+                var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
+                var networkPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Prefab));
+                var networkSourceHashProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourceHashToOverride));
+                var networkSourcePrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourcePrefabToOverride));
+                var networkTargetPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.OverridingTargetPrefab));
+                var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
+                var networkOverrideInt = networkOverrideProp.enumValueIndex;
+                var networkOverrideEnum = (NetworkPrefabOverride)networkOverrideInt;
+                EditorGUI.LabelField(new Rect(rect.x + rect.width - 70, rect.y, 60, EditorGUIUtility.singleLineHeight), "Override");
+                if (networkOverrideEnum == NetworkPrefabOverride.None)
+                {
+                    if (EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), false))
+                    {
+                        networkOverrideProp.enumValueIndex = (int)NetworkPrefabOverride.Prefab;
+                    }
+                }
+                else
+                {
+                    if (!EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), true))
+                    {
+                        networkOverrideProp.enumValueIndex = 0;
+                        networkOverrideEnum = NetworkPrefabOverride.None;
+                    }
+                }
+
+                if (networkOverrideEnum == NetworkPrefabOverride.None)
+                {
+                    EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width - 80, EditorGUIUtility.singleLineHeight), networkPrefabProp, GUIContent.none);
+                }
+                else
+                {
+                    networkOverrideProp.enumValueIndex = GUI.Toolbar(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), networkOverrideInt - 1, new[] { "Prefab", "Hash" }) + 1;
+
+                    if (networkOverrideEnum == NetworkPrefabOverride.Prefab)
+                    {
+                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourcePrefabProp, GUIContent.none);
+                    }
+                    else
+                    {
+                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourceHashProp, GUIContent.none);
+                    }
+
+                    rect.y += EditorGUIUtility.singleLineHeight + 5;
+
+                    EditorGUI.LabelField(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), "Overriding Prefab");
+                    EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 110, EditorGUIUtility.singleLineHeight), networkTargetPrefabProp, GUIContent.none);
+                }
+            };
+            m_NetworkPrefabsList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, "NetworkPrefabs");
+        }
+
+        public override void OnInspectorGUI()
+        {
+            using (new EditorGUI.DisabledScope(true))
+            {
+                EditorGUILayout.PropertyField(m_IsDefaultBool);
+            }
+
+            m_NetworkPrefabsList.DoLayoutList();
+
+            serializedObject.ApplyModifiedProperties();
+        }
+    }
+}
--- a/Editor/Configuration/NetworkPrefabsEditor.cs.meta
+++ b/Editor/Configuration/NetworkPrefabsEditor.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8d6d0919fa8ff41c9b1d1241256f7364
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
--- a/Editor/HiddenScriptEditor.cs
+++ b/Editor/HiddenScriptEditor.cs
@@ -4,6 +4,7 @@ using Unity.Netcode.Transports.UNET;
 #endif
 using Unity.Netcode.Transports.UTP;
 using UnityEditor;
+using UnityEngine;

 namespace Unity.Netcode.Editor
 {
@@ -43,7 +44,109 @@ namespace Unity.Netcode.Editor
    [CustomEditor(typeof(UnityTransport), true)]
    public class UnityTransportEditor : HiddenScriptEditor
    {
+        private static readonly string[] k_HiddenFields = { "m_Script", "ConnectionData" };

+        private bool m_AllowIncomingConnections;
+        private bool m_Initialized;
+
+        private UnityTransport m_UnityTransport;
+
+        private SerializedProperty m_ServerAddressProperty;
+        private SerializedProperty m_ServerPortProperty;
+        private SerializedProperty m_OverrideBindIpProperty;
+
+        private const string k_LoopbackIpv4 = "127.0.0.1";
+        private const string k_LoopbackIpv6 = "::1";
+        private const string k_AnyIpv4 = "0.0.0.0";
+        private const string k_AnyIpv6 = "::";
+
+
+        private void Initialize()
+        {
+            if (m_Initialized)
+            {
+                return;
+            }
+            m_Initialized = true;
+            m_UnityTransport = (UnityTransport)target;
+
+            var connectionDataProperty = serializedObject.FindProperty(nameof(UnityTransport.ConnectionData));
+
+            m_ServerAddressProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.Address));
+            m_ServerPortProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.Port));
+            m_OverrideBindIpProperty = connectionDataProperty.FindPropertyRelative(nameof(UnityTransport.ConnectionAddressData.ServerListenAddress));
+        }
+
+        /// <summary>
+        /// Draws inspector properties without the script field.
+        /// </summary>
+        public override void OnInspectorGUI()
+        {
+            Initialize();
+            EditorGUI.BeginChangeCheck();
+            serializedObject.UpdateIfRequiredOrScript();
+            DrawPropertiesExcluding(serializedObject, k_HiddenFields);
+            serializedObject.ApplyModifiedProperties();
+            EditorGUI.EndChangeCheck();
+
+            EditorGUILayout.PropertyField(m_ServerAddressProperty);
+            EditorGUILayout.PropertyField(m_ServerPortProperty);
+
+            serializedObject.ApplyModifiedProperties();
+
+            EditorGUILayout.HelpBox("It's recommended to leave remote connections disabled for local testing to avoid exposing ports on your device.", MessageType.Info);
+            bool allowRemoteConnections = m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv4 && m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv6 && !string.IsNullOrEmpty(m_UnityTransport.ConnectionData.ServerListenAddress);
+            allowRemoteConnections = EditorGUILayout.Toggle(new GUIContent("Allow Remote Connections?", $"Bind IP: {m_UnityTransport.ConnectionData.ServerListenAddress}"), allowRemoteConnections);
+
+            bool isIpV6 = m_UnityTransport.ConnectionData.IsIpv6;
+
+            if (!allowRemoteConnections)
+            {
+                if (m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv4 && m_UnityTransport.ConnectionData.ServerListenAddress != k_LoopbackIpv6)
+                {
+                    if (isIpV6)
+                    {
+                        m_UnityTransport.ConnectionData.ServerListenAddress = k_LoopbackIpv6;
+                    }
+                    else
+                    {
+                        m_UnityTransport.ConnectionData.ServerListenAddress = k_LoopbackIpv4;
+                    }
+                    EditorUtility.SetDirty(m_UnityTransport);
+                }
+            }
+
+            using (new EditorGUI.DisabledScope(!allowRemoteConnections))
+            {
+                string overrideIp = m_UnityTransport.ConnectionData.ServerListenAddress;
+                if (overrideIp == k_AnyIpv4 || overrideIp == k_AnyIpv6 || overrideIp == k_LoopbackIpv4 || overrideIp == k_LoopbackIpv6)
+                {
+                    overrideIp = "";
+                }
+
+                overrideIp = EditorGUILayout.TextField("Override Bind IP (optional)", overrideIp);
+                if (allowRemoteConnections)
+                {
+                    if (overrideIp == "")
+                    {
+                        if (isIpV6)
+                        {
+                            overrideIp = k_AnyIpv6;
+                        }
+                        else
+                        {
+                            overrideIp = k_AnyIpv4;
+                        }
+                    }
+
+                    if (m_UnityTransport.ConnectionData.ServerListenAddress != overrideIp)
+                    {
+                        m_UnityTransport.ConnectionData.ServerListenAddress = overrideIp;
+                        EditorUtility.SetDirty(m_UnityTransport);
+                    }
+                }
+            }
+        }
    }

 #if COM_UNITY_MODULES_ANIMATION
--- a/Editor/NetworkBehaviourEditor.cs
+++ b/Editor/NetworkBehaviourEditor.cs
@@ -20,6 +20,7 @@ namespace Unity.Netcode.Editor
        private readonly Dictionary<string, object> m_NetworkVariableObjects = new Dictionary<string, object>();

        private GUIContent m_NetworkVariableLabelGuiContent;
+        private GUIContent m_NetworkListLabelGuiContent;

        private void Init(MonoScript script)
        {
@@ -30,6 +31,7 @@ namespace Unity.Netcode.Editor
            m_NetworkVariableObjects.Clear();

            m_NetworkVariableLabelGuiContent = new GUIContent("NetworkVariable", "This variable is a NetworkVariable. It can not be serialized and can only be changed during runtime.");
+            m_NetworkListLabelGuiContent = new GUIContent("NetworkList", "This variable is a NetworkList. It is rendered, but you can't serialize or change it.");

            var fields = script.GetClass().GetFields(BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy);
            for (int i = 0; i < fields.Length; i++)
@@ -39,6 +41,13 @@ namespace Unity.Netcode.Editor
                {
                    m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name));
                    m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]);
+                    Debug.Log($"Adding NetworkVariable {fields[i].Name}");
+                }
+                if (ft.IsGenericType && ft.GetGenericTypeDefinition() == typeof(NetworkList<>) && !fields[i].IsDefined(typeof(HideInInspector), true))
+                {
+                    m_NetworkVariableNames.Add(ObjectNames.NicifyVariableName(fields[i].Name));
+                    m_NetworkVariableFields.Add(ObjectNames.NicifyVariableName(fields[i].Name), fields[i]);
+                    Debug.Log($"Adding NetworkList {fields[i].Name}");
                }
            }
        }
@@ -72,25 +81,48 @@ namespace Unity.Netcode.Editor
            EditorGUILayout.BeginHorizontal();
            if (genericType.IsValueType)
            {
-                var method = typeof(NetworkBehaviourEditor).GetMethod("RenderNetworkVariableValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
+                var method = typeof(NetworkBehaviourEditor).GetMethod("RenderNetworkContainerValueType", BindingFlags.Public | BindingFlags.Instance | BindingFlags.FlattenHierarchy | BindingFlags.NonPublic);
                var genericMethod = method.MakeGenericMethod(genericType);
                genericMethod.Invoke(this, new[] { (object)index });
            }
            else
            {
                EditorGUILayout.LabelField("Type not renderable");
+
+                GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x));
+                EditorGUILayout.EndHorizontal();
+            }
+        }
+
+        private void RenderNetworkContainerValueType<T>(int index) where T : unmanaged, IEquatable<T>
+        {
+            try
+            {
+                var networkVariable = (NetworkVariable<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
+                RenderNetworkVariableValueType(index, networkVariable);
+            }
+            catch (Exception)
+            {
+                try
+                {
+                    var networkList = (NetworkList<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
+                    RenderNetworkListValueType(index, networkList);
+                }
+                catch (Exception e)
+                {
+                    Debug.Log(e);
+                    throw;
+                }
            }

-            GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x));
            EditorGUILayout.EndHorizontal();
        }

-        private void RenderNetworkVariableValueType<T>(int index) where T : unmanaged
+        private void RenderNetworkVariableValueType<T>(int index, NetworkVariable<T> networkVariable) where T : unmanaged
        {
-            var networkVariable = (NetworkVariable<T>)m_NetworkVariableFields[m_NetworkVariableNames[index]].GetValue(target);
            var type = typeof(T);
            object val = networkVariable.Value;
-            string name = m_NetworkVariableNames[index];
+            string variableName = m_NetworkVariableNames[index];

            var behaviour = (NetworkBehaviour)target;

@@ -99,47 +131,47 @@ namespace Unity.Netcode.Editor
            {
                if (type == typeof(int))
                {
-                    val = EditorGUILayout.IntField(name, (int)val);
+                    val = EditorGUILayout.IntField(variableName, (int)val);
                }
                else if (type == typeof(uint))
                {
-                    val = (uint)EditorGUILayout.LongField(name, (long)((uint)val));
+                    val = (uint)EditorGUILayout.LongField(variableName, (long)((uint)val));
                }
                else if (type == typeof(short))
                {
-                    val = (short)EditorGUILayout.IntField(name, (int)((short)val));
+                    val = (short)EditorGUILayout.IntField(variableName, (int)((short)val));
                }
                else if (type == typeof(ushort))
                {
-                    val = (ushort)EditorGUILayout.IntField(name, (int)((ushort)val));
+                    val = (ushort)EditorGUILayout.IntField(variableName, (int)((ushort)val));
                }
                else if (type == typeof(sbyte))
                {
-                    val = (sbyte)EditorGUILayout.IntField(name, (int)((sbyte)val));
+                    val = (sbyte)EditorGUILayout.IntField(variableName, (int)((sbyte)val));
                }
                else if (type == typeof(byte))
                {
-                    val = (byte)EditorGUILayout.IntField(name, (int)((byte)val));
+                    val = (byte)EditorGUILayout.IntField(variableName, (int)((byte)val));
                }
                else if (type == typeof(long))
                {
-                    val = EditorGUILayout.LongField(name, (long)val);
+                    val = EditorGUILayout.LongField(variableName, (long)val);
                }
                else if (type == typeof(ulong))
                {
-                    val = (ulong)EditorGUILayout.LongField(name, (long)((ulong)val));
+                    val = (ulong)EditorGUILayout.LongField(variableName, (long)((ulong)val));
                }
                else if (type == typeof(bool))
                {
-                    val = EditorGUILayout.Toggle(name, (bool)val);
+                    val = EditorGUILayout.Toggle(variableName, (bool)val);
                }
                else if (type == typeof(string))
                {
-                    val = EditorGUILayout.TextField(name, (string)val);
+                    val = EditorGUILayout.TextField(variableName, (string)val);
                }
                else if (type.IsEnum)
                {
-                    val = EditorGUILayout.EnumPopup(name, (Enum)val);
+                    val = EditorGUILayout.EnumPopup(variableName, (Enum)val);
                }
                else
                {
@@ -150,11 +182,31 @@ namespace Unity.Netcode.Editor
            }
            else
            {
-                EditorGUILayout.LabelField(name, EditorStyles.wordWrappedLabel);
+                EditorGUILayout.LabelField(variableName, EditorStyles.wordWrappedLabel);
                EditorGUILayout.SelectableLabel(val.ToString(), EditorStyles.wordWrappedLabel);
            }
+            GUILayout.Label(m_NetworkVariableLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkVariableLabelGuiContent).x));
        }

+        private void RenderNetworkListValueType<T>(int index, NetworkList<T> networkList)
+            where T : unmanaged, IEquatable<T>
+        {
+            string variableName = m_NetworkVariableNames[index];
+
+            string value = "";
+            bool addComma = false;
+            foreach (var v in networkList)
+            {
+                if (addComma)
+                {
+                    value += ", ";
+                }
+                value += v.ToString();
+                addComma = true;
+            }
+            EditorGUILayout.LabelField(variableName, value);
+            GUILayout.Label(m_NetworkListLabelGuiContent, EditorStyles.miniLabel, GUILayout.Width(EditorStyles.miniLabel.CalcSize(m_NetworkListLabelGuiContent).x));
+        }

        /// <inheritdoc/>
        public override void OnInspectorGUI()
@@ -310,7 +362,7 @@ namespace Unity.Netcode.Editor
                    // and the user has already turned "Auto-Add NetworkObject" on when first notified about the requirement
                    // then just send a reminder to the user why the NetworkObject they just deleted seemingly "re-appeared"
                    // again.
-                    if (networkObjectRemoved && NetcodeForGameObjectsSettings.GetAutoAddNetworkObjectSetting())
+                    if (networkObjectRemoved && NetcodeForGameObjectsEditorSettings.GetAutoAddNetworkObjectSetting())
                    {
                        Debug.LogWarning($"{gameObject.name} still has {nameof(NetworkBehaviour)}s and Auto-Add NetworkObjects is enabled. A NetworkObject is being added back to {gameObject.name}.");
                        Debug.Log($"To reset Auto-Add NetworkObjects: Select the Netcode->General->Reset Auto-Add NetworkObject menu item.");
@@ -319,7 +371,7 @@ namespace Unity.Netcode.Editor
                    // Notify and provide the option to add it one time, always add a NetworkObject, or do nothing and let the user manually add it
                    if (EditorUtility.DisplayDialog($"{nameof(NetworkBehaviour)}s require a {nameof(NetworkObject)}",
                    $"{gameObject.name} does not have a {nameof(NetworkObject)} component.  Would you like to add one now?", "Yes", "No (manually add it)",
-                    DialogOptOutDecisionType.ForThisMachine, NetcodeForGameObjectsSettings.AutoAddNetworkObjectIfNoneExists))
+                    DialogOptOutDecisionType.ForThisMachine, NetcodeForGameObjectsEditorSettings.AutoAddNetworkObjectIfNoneExists))
                    {
                        gameObject.AddComponent<NetworkObject>();
                        var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
--- a/Editor/NetworkManagerEditor.cs
+++ b/Editor/NetworkManagerEditor.cs
@@ -1,8 +1,8 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
 using UnityEditor;
 using UnityEngine;
-using UnityEditorInternal;
 using Unity.Netcode.Editor.Configuration;

 namespace Unity.Netcode.Editor
@@ -40,8 +40,7 @@ namespace Unity.Netcode.Editor
        private SerializedProperty m_NetworkIdRecycleDelayProperty;
        private SerializedProperty m_RpcHashSizeProperty;
        private SerializedProperty m_LoadSceneTimeOutProperty;
-
-        private ReorderableList m_NetworkPrefabsList;
+        private SerializedProperty m_PrefabsList;

        private NetworkManager m_NetworkManager;
        private bool m_Initialized;
@@ -106,7 +105,9 @@ namespace Unity.Netcode.Editor
            m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay");
            m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
            m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
-
+            m_PrefabsList = m_NetworkConfigProperty
+                .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
+                .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));

            ReloadTransports();
        }
@@ -132,76 +133,9 @@ namespace Unity.Netcode.Editor
            m_NetworkIdRecycleDelayProperty = m_NetworkConfigProperty.FindPropertyRelative("NetworkIdRecycleDelay");
            m_RpcHashSizeProperty = m_NetworkConfigProperty.FindPropertyRelative("RpcHashSize");
            m_LoadSceneTimeOutProperty = m_NetworkConfigProperty.FindPropertyRelative("LoadSceneTimeOut");
-        }
-
-        private void OnEnable()
-        {
-            m_NetworkPrefabsList = new ReorderableList(serializedObject, serializedObject.FindProperty(nameof(NetworkManager.NetworkConfig)).FindPropertyRelative(nameof(NetworkConfig.NetworkPrefabs)), true, true, true, true);
-            m_NetworkPrefabsList.elementHeightCallback = index =>
-            {
-                var networkOverrideInt = 0;
-                if (m_NetworkPrefabsList.count > 0)
-                {
-                    var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
-                    var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
-                    networkOverrideInt = networkOverrideProp.enumValueIndex;
-                }
-
-                return 8 + (networkOverrideInt == 0 ? EditorGUIUtility.singleLineHeight : (EditorGUIUtility.singleLineHeight * 2) + 5);
-            };
-            m_NetworkPrefabsList.drawElementCallback = (rect, index, isActive, isFocused) =>
-            {
-                rect.y += 5;
-
-                var networkPrefab = m_NetworkPrefabsList.serializedProperty.GetArrayElementAtIndex(index);
-                var networkPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Prefab));
-                var networkSourceHashProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourceHashToOverride));
-                var networkSourcePrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.SourcePrefabToOverride));
-                var networkTargetPrefabProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.OverridingTargetPrefab));
-                var networkOverrideProp = networkPrefab.FindPropertyRelative(nameof(NetworkPrefab.Override));
-                var networkOverrideInt = networkOverrideProp.enumValueIndex;
-                var networkOverrideEnum = (NetworkPrefabOverride)networkOverrideInt;
-                EditorGUI.LabelField(new Rect(rect.x + rect.width - 70, rect.y, 60, EditorGUIUtility.singleLineHeight), "Override");
-                if (networkOverrideEnum == NetworkPrefabOverride.None)
-                {
-                    if (EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), false))
-                    {
-                        networkOverrideProp.enumValueIndex = (int)NetworkPrefabOverride.Prefab;
-                    }
-                }
-                else
-                {
-                    if (!EditorGUI.Toggle(new Rect(rect.x + rect.width - 15, rect.y, 10, EditorGUIUtility.singleLineHeight), true))
-                    {
-                        networkOverrideProp.enumValueIndex = 0;
-                        networkOverrideEnum = NetworkPrefabOverride.None;
-                    }
-                }
-
-                if (networkOverrideEnum == NetworkPrefabOverride.None)
-                {
-                    EditorGUI.PropertyField(new Rect(rect.x, rect.y, rect.width - 80, EditorGUIUtility.singleLineHeight), networkPrefabProp, GUIContent.none);
-                }
-                else
-                {
-                    networkOverrideProp.enumValueIndex = GUI.Toolbar(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), networkOverrideInt - 1, new[] { "Prefab", "Hash" }) + 1;
-
-                    if (networkOverrideEnum == NetworkPrefabOverride.Prefab)
-                    {
-                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourcePrefabProp, GUIContent.none);
-                    }
-                    else
-                    {
-                        EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 190, EditorGUIUtility.singleLineHeight), networkSourceHashProp, GUIContent.none);
-                    }
-
-                    rect.y += EditorGUIUtility.singleLineHeight + 5;
-
-                    EditorGUI.LabelField(new Rect(rect.x, rect.y, 100, EditorGUIUtility.singleLineHeight), "Overriding Prefab");
-                    EditorGUI.PropertyField(new Rect(rect.x + 110, rect.y, rect.width - 110, EditorGUIUtility.singleLineHeight), networkTargetPrefabProp, GUIContent.none);
-                }
-            };
-            m_NetworkPrefabsList.drawHeaderCallback = rect => EditorGUI.LabelField(rect, "NetworkPrefabs");
+            m_PrefabsList = m_NetworkConfigProperty
+                .FindPropertyRelative(nameof(NetworkConfig.Prefabs))
+                .FindPropertyRelative(nameof(NetworkPrefabs.NetworkPrefabsLists));
        }

        /// <inheritdoc/>
@@ -224,7 +158,62 @@ namespace Unity.Netcode.Editor
                EditorGUILayout.PropertyField(m_PlayerPrefabProperty);
                EditorGUILayout.Space();

-                m_NetworkPrefabsList.DoLayoutList();
+                if (m_NetworkManager.NetworkConfig.HasOldPrefabList())
+                {
+                    EditorGUILayout.HelpBox("Network Prefabs serialized in old format. Migrate to new format to edit the list.", MessageType.Info);
+                    if (GUILayout.Button(new GUIContent("Migrate Prefab List", "Converts the old format Network Prefab list to a new Scriptable Object")))
+                    {
+                        // Default directory
+                        var directory = "Assets/";
+                        var assetPath = AssetDatabase.GetAssetPath(m_NetworkManager);
+                        if (assetPath == "")
+                        {
+                            assetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(m_NetworkManager);
+                        }
+
+                        if (assetPath != "")
+                        {
+                            directory = Path.GetDirectoryName(assetPath);
+                        }
+                        else
+                        {
+#if UNITY_2021_1_OR_NEWER
+                            var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
+#else
+                            var prefabStage = UnityEditor.Experimental.SceneManagement.PrefabStageUtility.GetPrefabStage(m_NetworkManager.gameObject);
+#endif
+                            if (prefabStage != null)
+                            {
+                                var prefabPath = prefabStage.assetPath;
+                                if (!string.IsNullOrEmpty(prefabPath))
+                                {
+                                    directory = Path.GetDirectoryName(prefabPath);
+                                }
+                            }
+                            if (m_NetworkManager.gameObject.scene != null)
+                            {
+                                var scenePath = m_NetworkManager.gameObject.scene.path;
+                                if (!string.IsNullOrEmpty(scenePath))
+                                {
+                                    directory = Path.GetDirectoryName(scenePath);
+                                }
+                            }
+                        }
+                        var networkPrefabs = m_NetworkManager.NetworkConfig.MigrateOldNetworkPrefabsToNetworkPrefabsList();
+                        string path = Path.Combine(directory, $"NetworkPrefabs-{m_NetworkManager.GetInstanceID()}.asset");
+                        Debug.Log("Saving migrated Network Prefabs List to " + path);
+                        AssetDatabase.CreateAsset(networkPrefabs, path);
+                        EditorUtility.SetDirty(m_NetworkManager);
+                    }
+                }
+                else
+                {
+                    if (m_NetworkManager.NetworkConfig.Prefabs.NetworkPrefabsLists.Count == 0)
+                    {
+                        EditorGUILayout.HelpBox("You have no prefab list selected. You will have to add your prefabs manually at runtime for netcode to work.", MessageType.Warning);
+                    }
+                    EditorGUILayout.PropertyField(m_PrefabsList);
+                }
                EditorGUILayout.Space();

                EditorGUILayout.LabelField("General", EditorStyles.boldLabel);
@@ -359,7 +348,7 @@ namespace Unity.Netcode.Editor
            const string targetUrl = "https://docs-multiplayer.unity3d.com/netcode/current/tools/install-tools";
            const string infoIconName = "console.infoicon";

-            if (NetcodeForGameObjectsSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
+            if (NetcodeForGameObjectsEditorSettings.GetNetcodeInstallMultiplayerToolTips() != 0)
            {
                return;
            }
@@ -405,7 +394,7 @@ namespace Unity.Netcode.Editor
                GUILayout.FlexibleSpace();
                if (GUILayout.Button(dismissButtonText, dismissButtonStyle, GUILayout.ExpandWidth(false)))
                {
-                    NetcodeForGameObjectsSettings.SetNetcodeInstallMultiplayerToolTips(1);
+                    NetcodeForGameObjectsEditorSettings.SetNetcodeInstallMultiplayerToolTips(1);
                }
                EditorGUIUtility.AddCursorRect(GUILayoutUtility.GetLastRect(), MouseCursor.Link);
                GUILayout.FlexibleSpace();
--- a/Editor/NetworkManagerHelper.cs
+++ b/Editor/NetworkManagerHelper.cs
@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
+using Unity.Netcode.Editor.Configuration;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 using UnityEditor;
@@ -32,6 +33,24 @@ namespace Unity.Netcode.Editor

            EditorApplication.playModeStateChanged += EditorApplication_playModeStateChanged;
            EditorApplication.hierarchyChanged += EditorApplication_hierarchyChanged;
+
+            // Initialize default values for new NetworkManagers
+            //
+            // When the default prefab list is enabled, this will default
+            // new NetworkManagers to using it.
+            //
+            // This will get run when new NetworkManagers are added, and
+            // when the user presses the "reset" button on a NetworkManager
+            // in the inspector.
+            NetworkManager.OnNetworkManagerReset = manager =>
+            {
+                var settings = NetcodeForGameObjectsProjectSettings.instance;
+                if (settings.GenerateDefaultNetworkPrefabs)
+                {
+                    manager.NetworkConfig = new NetworkConfig();
+                    manager.NetworkConfig.Prefabs.NetworkPrefabsLists = new List<NetworkPrefabsList> { NetworkPrefabProcessor.GetOrCreateNetworkPrefabs(NetworkPrefabProcessor.DefaultNetworkPrefabsPath, out _, true) };
+                }
+            };
        }

        private static void EditorApplication_playModeStateChanged(PlayModeStateChange playModeStateChange)