chore: n4e 7.0.0 spellings, review feedback and snapshot size

N4E 7.0.0 renamed NetCodeConfig to NetcodeConfig and moved its types into
Unity.Netcode. Use the 7.0.0 spelling, aliased for 6.7.0 the way the rest of
the unified code already is.

The editor test assembly still declared UNIFIED_NETCODE as a versionDefine
after #4158 made it project-level, so its unified block compiled while the
runtime's did not. It also referenced Unity.NetCode by name alongside the GUID
for the same assembly. Both removed, UNIFIED_NETCODE_7_0_0 added.

The snapshot packet size drops from 15000 to 4096. A snapshot is sent
unreliably, so losing any one of its fragments loses the whole snapshot: 4096
spans 3 datagrams at the 1400 byte MTU where 15000 spanned 11, and still caps
~840 ghosts at the measured 4.87 bytes each. The defaults version is bumped so
a project that already recorded the marker picks the new value up.

Review feedback:
- The experimental opt-in is gone. N4E ships as a normal 3.0.0 release.
- ResolveGlobalConfig's project scan is gone. N4E assigns NetcodeConfig.Global
  from an InitializeOnLoadMethod and delayCall runs after those complete, so
  there is nothing left for a scan to catch.
- The apply log uses the contextual logger at Developer level.
- UnifiedIsConfiguredCorrectly reports which setting is wrong rather than
  discarding the reason it already computed.

Author: NoelStephensUnity

com.unity.netcode.gameobjects/Editor/Configuration/HybridNetcodeConfigApplier.cs

@@ -1,41 +1,30 @@
 #if UNIFIED_NETCODE
-using Unity.NetCode;
+using Unity.Netcode.Logging;
+#if !UNIFIED_NETCODE_7_0_0
+using NetcodeConfig = Unity.NetCode.NetCodeConfig;
+#endif
 using UnityEditor;
-using UnityEngine;
 
 namespace Unity.Netcode.GameObjects.Editor.Configuration
 {
     /// <summary>
-    /// Writes the <see cref="NetCodeConfig"/> values NGO recommends for hybrid mode, once, the first time a
-    /// <see cref="NetCodeConfig"/> is available.
+    /// Writes the <see cref="NetcodeConfig"/> values NGO recommends for hybrid mode, once, the first time a
+    /// <see cref="NetcodeConfig"/> is available.
     /// </summary>
     /// <remarks>
-    /// This does not create <see cref="NetCodeConfig"/>. This finds the one N4E created and modifies it.
+    /// This does not create <see cref="NetcodeConfig"/>. This finds the one N4E created and modifies it.
     /// Nothing tracks the project after that write. The defaults are inert in a project with no hybrid prefabs, and
     /// <see cref="NetworkManager"/> re-aligns the tick rate at start-up in a project that has them, so there is no
     /// reason to scan for ghost prefabs from the editor.
     /// </remarks>
     internal static class HybridNetcodeConfigApplier
     {
-        /// <summary>
-        /// Whether the user has to opt into the experimental unified netcode API before NGO writes anything.
-        /// </summary>
-        /// <remarks>
-        /// TODO-RELEASE: Set this to true before the 6000.7.0 release manifest submission if Netcode for Entities
-        /// ships the unified API as experimental and its scripting defines.
-        /// Note: This is deliberately not a const: IDE0035 (remove unreachable code) is an error in this repository, so a
-        /// const would fail the standards job as soon as it was set to false.
-        /// </remarks>
-        internal static readonly bool RequiresExperimentalOptIn = false;
-
-        private static NetCodeConfig s_ScannedConfig;
-        private static bool s_ConfigScanned;
-
         [InitializeOnLoadMethod]
         private static void OnApplicationStart()
         {
-            // Cross-assembly ordering between the two is not a documented contract.
-            // Defer rather than racing it.
+            // N4E assigns NetcodeConfig.Global from its own [InitializeOnLoadMethod] and creates the asset when
+            // there is none. delayCall runs after those have completed, which is what makes Global reliable here
+            // without a lookup of our own.
             EditorApplication.delayCall += OnDelayCall;
         }
 
@@ -46,7 +35,7 @@ private static void OnDelayCall()
         }
 
         /// <summary>
-        /// Writes the NGO hybrid mode defaults into the project's <see cref="NetCodeConfig"/>.
+        /// Writes the NGO hybrid mode defaults into the project's <see cref="NetcodeConfig"/>.
         /// </summary>
         /// <param name="force">
         /// Driven by the button in Project Settings:
@@ -62,19 +51,14 @@ internal static void ApplyDefaults(bool force)
             }
 
             var settings = NetcodeForGameObjectsProjectSettings.instance;
-            if (RequiresExperimentalOptIn && !settings.EnableUnifiedNetcodeApi)
-            {
-                return;
-            }
-
             if (!force && settings.HybridDefaultsVersion >= HybridNetcodeDefaults.Version)
             {
                 return;
             }
 
             // A project with no config yet leaves the marker unrecorded so that the next domain reload tries again.
             // N4E creates one on any domain reload that finds none.
-            var config = ResolveGlobalConfig();
+            var config = NetcodeConfig.Global;
             if (config == null)
             {
                 return;
@@ -84,40 +68,14 @@ internal static void ApplyDefaults(bool force)
             {
                 EditorUtility.SetDirty(config);
                 AssetDatabase.SaveAssetIfDirty(config);
-                Debug.Log($"[Netcode] Applied the NGO hybrid mode defaults to '{config.name}'. These are tuned for NGO and can be changed freely; they will not be re-applied automatically. Use Project Settings > Multiplayer > Netcode for GameObjects to restore them.", config);
+                new ContextualLogger(config).Info(new Context(LogLevel.Developer, $"Applied the hybrid mode defaults to '{config.name}'. These are tuned for Netcode for GameObjects and can be changed freely; they will not be re-applied automatically. Use Project Settings > Multiplayer > Netcode for GameObjects to restore them.").AddTag("Unified"));
             }
 
             // Recorded even when the config already matched and nothing was written. Leaving it unrecorded would make
             // the next domain reload a first application again, which would revert the user's next edit.
             settings.HybridDefaultsVersion = HybridNetcodeDefaults.Version;
             settings.SaveSettings();
         }
-
-        /// <summary>
-        /// Resolves the config N4E considers global, falling back to a project scan when N4E has not assigned one yet.
-        /// </summary>
-        /// <remarks>
-        /// The scan is done at most once per domain reload, including when it finds nothing, because this is also
-        /// reached from OnGUI and <see cref="AssetDatabase.FindAssets"/> walks the entire project. A config created
-        /// after the scan is picked up on the next domain reload.
-        /// </remarks>
-        /// <returns>The config to adjust or null if no config exists.</returns>
-        internal static NetCodeConfig ResolveGlobalConfig()
-        {
-            if (NetCodeConfig.Global != null)
-            {
-                return NetCodeConfig.Global;
-            }
-
-            if (!s_ConfigScanned)
-            {
-                s_ConfigScanned = true;
-                var guids = AssetDatabase.FindAssets($"t:{nameof(NetCodeConfig)}");
-                s_ScannedConfig = guids.Length == 1 ? AssetDatabase.LoadAssetAtPath<NetCodeConfig>(AssetDatabase.GUIDToAssetPath(guids[0])) : null;
-            }
-
-            return s_ScannedConfig;
-        }
     }
 }
 #endif

com.unity.netcode.gameobjects/Editor/Configuration/NetcodeForGameObjectsProjectSettings.cs

@@ -39,22 +39,12 @@ private void OnEnable()
 
 #if UNIFIED_NETCODE
         /// <summary>
-        /// Whether the user has opted into the experimental unified netcode API.
+        /// The version of the hybrid mode default values already written into this project's NetcodeConfig, or zero
+        /// when they have never been written.
         /// </summary>
         /// <remarks>
-        /// Only consulted while <see cref="HybridNetcodeConfigApplier.RequiresExperimentalOptIn"/> holds. Turning it
-        /// off again hides the hybrid section and leaves the NetCodeConfig exactly as it is; the marker below is what
-        /// keeps turning it back on from overwriting anything.
-        /// </remarks>
-        [SerializeField]
-        public bool EnableUnifiedNetcodeApi;
-
-        /// <summary>
-        /// The hybrid mode default values already applied to this project's NetCodeConfig.
-        /// </summary>
-        /// <remarks>
-        /// Zero means they have never been applied. Persisting this value is what keeps the tuned values a one-shot.
-        /// For users who deliberately change them, they are not overwritten on the next domain reload.
+        /// A version rather than a flag so a later revision of those values re-applies exactly once. Recording it is
+        /// what keeps them a one-shot: a user who changes them is not overwritten on the next domain reload.
         /// </remarks>
         [SerializeField]
         public int HybridDefaultsVersion;

com.unity.netcode.gameobjects/Editor/Configuration/NetcodeSettingsProvider.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.IO;
-#if UNIFIED_NETCODE
-using Unity.NetCode;
+#if UNIFIED_NETCODE && !UNIFIED_NETCODE_7_0_0
+using NetcodeConfig = Unity.NetCode.NetCodeConfig;
 #endif
 using UnityEditor;
 using UnityEngine;
@@ -14,9 +14,6 @@ internal static class NetcodeSettingsProvider
     {
         private const float k_MaxLabelWidth = 450f;
         private static float s_MaxLabelWidth;
-#if UNIFIED_NETCODE
-        private static float s_HybridLabelWidth;
-#endif
         private static bool s_ShowEditorSettingFields = true;
         private static bool s_ShowProjectSettingFields = true;
 
@@ -218,29 +215,24 @@ private static void OnGuiHandler(string obj)
 
 #if UNIFIED_NETCODE
         /// <summary>
-        /// Displays the NetCodeConfig the NGO hybrid mode defaults were written into, and offers a way to restore
+        /// Displays the NetcodeConfig the NGO hybrid mode defaults were written into, and offers a way to restore
         /// those defaults for anyone who has since changed them.
         /// </summary>
-        /// <param name="settings">The project settings holding the opt-in flag and the applied-defaults marker.</param>
+        /// <param name="settings">The project settings holding the applied-defaults marker.</param>
         private static void DrawHybridSettings(NetcodeForGameObjectsProjectSettings settings)
         {
-            if (HybridNetcodeConfigApplier.RequiresExperimentalOptIn && !DrawUnifiedNetcodeApiToggle(settings))
-            {
-                return;
-            }
-
             GUILayout.BeginVertical("Box");
             GUILayout.Label("Hybrid (Netcode for Entities)", EditorStyles.boldLabel);
 
-            var config = HybridNetcodeConfigApplier.ResolveGlobalConfig();
+            var config = NetcodeConfig.Global;
             if (config == null)
             {
-                EditorGUILayout.HelpBox("No NetCodeConfig could be resolved. Open Project Settings > Multiplayer, which creates one, then reload the project.", MessageType.Warning);
+                EditorGUILayout.HelpBox("No NetcodeConfig has been assigned yet. Open Project Settings > Multiplayer, which creates one, then reload the project.", MessageType.Warning);
                 GUILayout.EndVertical();
                 return;
             }
 
-            EditorGUILayout.ObjectField(new GUIContent("Applied to", "The NetCodeConfig that Netcode for GameObjects wrote its hybrid mode defaults into."), config, typeof(NetCodeConfig), false);
+            EditorGUILayout.ObjectField(new GUIContent("Applied to", "The NetcodeConfig that Netcode for GameObjects wrote its hybrid mode defaults into."), config, typeof(NetcodeConfig), false);
 
             if (settings.HybridDefaultsVersion < HybridNetcodeDefaults.Version)
             {
@@ -254,44 +246,6 @@ private static void DrawHybridSettings(NetcodeForGameObjectsProjectSettings sett
 
             GUILayout.EndVertical();
         }
-
-        /// <summary>
-        /// Draws the opt-in for the experimental unified netcode API, writing the NGO hybrid mode defaults the first
-        /// time it is checked.
-        /// </summary>
-        /// <param name="settings">The project settings holding the opt-in flag.</param>
-        /// <returns>Whether the rest of the hybrid section should draw.</returns>
-        private static bool DrawUnifiedNetcodeApiToggle(NetcodeForGameObjectsProjectSettings settings)
-        {
-            const string enableUnifiedApiString = "Enable the experimental unified netcode API";
-
-            if (s_HybridLabelWidth == 0)
-            {
-                s_HybridLabelWidth = Mathf.Min(k_MaxLabelWidth, EditorStyles.label.CalcSize(new GUIContent(enableUnifiedApiString)).x);
-            }
-
-            EditorGUIUtility.labelWidth = s_HybridLabelWidth;
-            var enabled = EditorGUILayout.Toggle(
-                new GUIContent(
-                    enableUnifiedApiString,
-                    "When enabled, Netcode for GameObjects writes the NetCodeConfig values it recommends for hybrid " +
-                    "mode. Disabling it again hides these settings and leaves the NetCodeConfig as it is."),
-                settings.EnableUnifiedNetcodeApi,
-                GUILayout.Width(s_HybridLabelWidth + 20));
-            EditorGUIUtility.labelWidth = s_MaxLabelWidth;
-
-            if (enabled != settings.EnableUnifiedNetcodeApi)
-            {
-                settings.EnableUnifiedNetcodeApi = enabled;
-                settings.SaveSettings();
-                if (enabled)
-                {
-                    HybridNetcodeConfigApplier.ApplyDefaults(false);
-                }
-            }
-
-            return enabled;
-        }
 #endif
     }