Merge develop-2.0.0 into chore/optimize-network-transform-state

Author: netcode-ci-service

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -11,6 +11,8 @@ Additional documentation and release notes are available at [Multiplayer Documen
 ### Added
 
 - It is now possible to control which port clients will bind to using the `UnityTransport.ConnectionData.ClientBindPort` field. If not set, clients will bind to an ephemeral port (same as before this change). (#3764)
+- Added a flag to override command-line arguments (port and ip) in `SetConnectionData`. (#3760)
+- Added a command-line singleton to parse environment command-line arguments. (#3760)
 
 
 ### Changed
@@ -29,7 +31,7 @@ Additional documentation and release notes are available at [Multiplayer Documen
 - Fixed issues with the "Client-server quickstart for Netcode for GameObjects" script having static methods and properties. (#3787)
 - Fixed issue where invoking an RPC, on another `NetworkBehaviour` associated with the same `NetworkObject` that is ordered before the `NetworkBehaviour` invoking the RPC, during `OnNetworkSpawn` could throw an exception if scene management is disabled. (#3782)
 - Fixed issue where the `Axis to Synchronize` toggles didn't work with multi object editing in `NetworkTransform`. (#3781)
-
+- Fixed issue where using the dedicated server package would override all attempts to change the port by code. (#3760)
 
 ### Security
 

com.unity.netcode.gameobjects/Documentation~/TableOfContents.md

@@ -19,6 +19,7 @@
     * [Max players](basics/maxnumberplayers.md)
   * [Transports](advanced-topics/transports.md)
   * [Unity Relay](relay/relay.md)
+  * [Command-line arguments](command-line-arguments.md)
 * [Network components](network-components.md)
   * [Core components](components/core/corecomponents.md)
     * [NetworkObject](components/core/networkobject.md)

com.unity.netcode.gameobjects/Documentation~/basics/maxnumberplayers.md

@@ -21,7 +21,7 @@ if( m_Portal.NetManager.ConnectedClientsIds.Count >= CharSelectData.k_MaxLobbyPl
 }
 ```
 
-> [!NOTE]​
+> [!NOTE]
 > In connection approval delegate, Netcode for GameObjects doesn't support sending anything more than a Boolean back.
 
 <!-- Commenting this out until we can get external code references working

com.unity.netcode.gameobjects/Documentation~/command-line-arguments.md

@@ -0,0 +1,62 @@
+# Command-line arguments
+
+Use [command-line arguments](https://docs.unity3d.com/Documentation/Manual/CommandLineArguments.html) to configure certain aspects of your game at launch. This is especially useful for dedicated server builds, where arguments let you override default network settings such as the IP address and port.
+
+## Using command-line arguments
+
+When launching a standalone build (such as a headless dedicated server), you can supply custom arguments to modify runtime behavior.
+
+Reserved arguments:
+
+- `-port`
+- `-ip`
+
+Unity provides built-in parsing for standard arguments, and you can extend this behavior by adding your own.
+
+## Custom arguments
+
+You can define additional custom command-line arguments and retrieve them through the `CommandLineOptions` class. Use `GetArgs()` in your project code to collect and process these values.
+
+> [!NOTE]
+> Adding a custom command-line argument requires you to explicitly retrieve and handle it in your implementation.
+
+## Example
+
+The following code shows you an example of defining and then reading a custom command-line argument.
+```
+private const string k_OverrideArg = "-argName";
+
+private bool ParseCommandLineOptions(out string command)
+{
+    if (CommandLineOptions.Instance.GetArg(k_OverrideArg) is string argValue)
+    {
+        command = argValue;
+        return true;
+    }
+    command = default;
+    return false;
+}
+```
+
+Usage example:
+
+```
+if (ParseCommandLineOptions(out var command))
+{
+    // Your logic here
+}
+```
+
+## Override connection data
+
+If you want to ignore the connection port provided through command-line arguments, you can override it by using the optional `forceOverride` parameter in:
+
+```
+UnityTransport.SetConnectionData(string ip, ushort port, string listenAddress, bool forceOverride);
+```
+
+Setting `forceOverride` to `true` ensures that the values you pass to `SetConnectionData` override any values specified via command-line arguments.
+
+## Additional resources
+
+- [Command-line arguments in the Unity Manual](https://docs.unity3d.com/6000.2/Documentation/Manual/CommandLineArguments.html)

com.unity.netcode.gameobjects/Documentation~/configuration.md

@@ -2,8 +2,10 @@
 
 Configure your Netcode for GameObjects project.
 
-| **Topic**                       | **Description**                  |
-| :------------------------------ | :------------------------------- |
-| **[Configuring connections](configure-connections.md)** | Configure connections in your project. |
-| **[Transports](advanced-topics/transports.md)**| Transport layers establish communication between your application and different hosts in a network. |
-| **[Unity Relay](relay/relay.md)**| Use Unity Relay with Netcode for GameObjects to connect clients and hosts over the internet using a relay server. |
+
+| **Topic**                                               | **Description**                                                                                                   |
+|:--------------------------------------------------------|:------------------------------------------------------------------------------------------------------------------|
+| **[Configuring connections](configure-connections.md)** | Configure connections in your project.                                                                            |
+| **[Transports](advanced-topics/transports.md)**         | Transport layers establish communication between your application and different hosts in a network.               |
+| **[Unity Relay](relay/relay.md)**                       | Use Unity Relay with Netcode for GameObjects to connect clients and hosts over the internet using a relay server. |
+| **[Command-line arguments](command-line-arguments.md)** | Use command-line arguments to configure certain aspects of your game at launch.                                                                              |

com.unity.netcode.gameobjects/Runtime/Configuration/CommandLineOptions.cs

@@ -0,0 +1,63 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Unity.Netcode
+{
+    /// <summary>
+    /// This class contains a list of the application instance domain's command line arguments that
+    /// are used when entering PlayMode or the build is executed.
+    /// </summary>
+    public class CommandLineOptions
+    {
+        /// <summary>
+        /// Command-line options singleton
+        /// </summary>
+        public static CommandLineOptions Instance
+        {
+            get
+            {
+                if (s_Instance == null)
+                {
+                    s_Instance = new CommandLineOptions();
+                }
+                return s_Instance;
+            }
+            private set
+            {
+                s_Instance = value;
+            }
+        }
+        private static CommandLineOptions s_Instance;
+
+        [RuntimeInitializeOnLoadMethod(RuntimeInitializeLoadType.SubsystemRegistration)]
+        private static void RuntimeInitializeOnLoad() => Instance = new CommandLineOptions();
+
+        // Contains the current application instance domain's command line arguments
+        internal static List<string> CommandLineArguments = new List<string>();
+
+        // Invoked upon application start, after scene load
+        [RuntimeInitializeOnLoadMethod]
+        private static void ParseCommandLineArguments()
+        {
+            // Get all the command line arguments to be parsed later and/or modified
+            // prior to being parsed (for testing purposes).
+            CommandLineArguments = new List<string>(Environment.GetCommandLineArgs());
+        }
+
+        /// <summary>
+        /// Returns the value of an argument or null if there the argument is not present
+        /// </summary>
+        /// <param name="arg">The name of the argument</param>
+        /// <returns><see cref="string"/>Value of the command line argument passed in.</returns>
+        public string GetArg(string arg)
+        {
+            var argIndex = CommandLineArguments.IndexOf(arg);
+            if (argIndex >= 0 && argIndex < CommandLineArguments.Count - 1)
+            {
+                return CommandLineArguments[argIndex + 1];
+            }
+            return null;
+        }
+    }
+}

com.unity.netcode.gameobjects/Runtime/Configuration/CommandLineOptions.cs.meta

@@ -974,19 +974,6 @@ public NetworkPrefabHandler PrefabHandler
         internal NetworkConnectionManager ConnectionManager = new NetworkConnectionManager();
         internal NetworkMessageManager MessageManager = null;
 
-        internal struct Override<T>
-        {
-            private T m_Value;
-            public bool Overidden { get; private set; }
-            internal T Value
-            {
-                get { return Overidden ? m_Value : default(T); }
-                set { Overidden = true; m_Value = value; }
-            }
-        };
-
-        internal Override<ushort> PortOverride;
-
         /// <summary>
         /// Determines if the NetworkManager's GameObject is parented under another GameObject and
         /// notifies the user that this is not allowed for the NetworkManager.
@@ -1166,8 +1153,6 @@ internal void Initialize(bool server)
                 return;
             }
 
-            ParseCommandLineOptions();
-
             if (NetworkConfig.NetworkTransport == null)
             {
                 if (NetworkLog.CurrentLogLevel <= LogLevel.Error)
@@ -1738,40 +1723,6 @@ private void OnDestroy()
 #endif
         }
 
-        // Command line options
-        private const string k_OverridePortArg = "-port";
-
-        private string GetArg(string[] commandLineArgs, string arg)
-        {
-            var argIndex = Array.IndexOf(commandLineArgs, arg);
-            if (argIndex >= 0 && argIndex < commandLineArgs.Length - 1)
-            {
-                return commandLineArgs[argIndex + 1];
-            }
-
-            return null;
-        }
-
-        private void ParseArg<T>(string arg, ref Override<T> value)
-        {
-            if (GetArg(Environment.GetCommandLineArgs(), arg) is string argValue)
-            {
-                value.Value = (T)Convert.ChangeType(argValue, typeof(T));
-            }
-        }
-
-        private void ParseCommandLineOptions()
-        {
-#if UNITY_SERVER && UNITY_DEDICATED_SERVER_ARGUMENTS_PRESENT
-            if ( UnityEngine.DedicatedServer.Arguments.Port != null)
-            {
-                PortOverride.Value = (ushort)UnityEngine.DedicatedServer.Arguments.Port;
-            }
-#else
-            ParseArg(k_OverridePortArg, ref PortOverride);
-#endif
-        }
-
 #if UNITY_EDITOR
         internal static INetworkManagerHelper NetworkManagerHelper;
 

com.unity.netcode.gameobjects/Runtime/Core/NetworkManager.cs

@@ -805,6 +805,40 @@ public void SetClientRelayData(string ipAddress, ushort port, byte[] allocationI
             SetRelayServerData(ipAddress, port, allocationId, key, connectionData, hostConnectionData, isSecure);
         }
 
+        // Command line options
+        private const string k_OverridePortArg = "-port";
+        private const string k_OverrideIpAddressArg = "-ip";
+
+        private bool ParseCommandLineOptionsPort(out ushort port)
+        {
+#if UNITY_SERVER && UNITY_DEDICATED_SERVER_ARGUMENTS_PRESENT
+            if (UnityEngine.DedicatedServer.Arguments.Port != null)
+            {
+                port = (ushort)UnityEngine.DedicatedServer.Arguments.Port;
+                return true;
+            }
+#else
+            if (CommandLineOptions.Instance.GetArg(k_OverridePortArg) is string argValue)
+            {
+                port = (ushort)Convert.ChangeType(argValue, typeof(ushort));
+                return true;
+            }
+#endif
+            port = default;
+            return false;
+        }
+
+        private bool ParseCommandLineOptionsAddress(out string ipValue)
+        {
+            if (CommandLineOptions.Instance.GetArg(k_OverrideIpAddressArg) is string argValue)
+            {
+                ipValue = argValue;
+                return true;
+            }
+            ipValue = default;
+            return false;
+        }
+
         /// <summary>
         /// Sets IP and Port information. This will be ignored if using the Unity Relay and you should call <see cref="SetRelayServerData"/>
         /// </summary>
@@ -813,6 +847,29 @@ public void SetClientRelayData(string ipAddress, ushort port, byte[] allocationI
         /// <param name="listenAddress">The address the server is going to listen on.</param>
         public void SetConnectionData(string ipv4Address, ushort port, string listenAddress = null)
         {
+            SetConnectionData(false, ipv4Address, port, listenAddress);
+        }
+
+        /// <summary>
+        /// Sets IP and Port information. This will be ignored if using the Unity Relay and you should call <see cref="SetRelayServerData"/>
+        /// </summary>
+        /// <param name="ipv4Address">The remote IP address (despite the name, can be an IPv6 address or a domain name).</param>
+        /// <param name="port">The remote port to connect to.</param>
+        /// <param name="listenAddress">The address the server is going to listen on.</param>
+        /// <param name="forceOverrideCommandLineArgs">When true, -port and -ip command line arguments will be ignored.</param>
+        public void SetConnectionData(bool forceOverrideCommandLineArgs, string ipv4Address, ushort port, string listenAddress = null)
+        {
+            m_HasForcedConnectionData = forceOverrideCommandLineArgs;
+            if (!forceOverrideCommandLineArgs && ParseCommandLineOptionsPort(out var commandLinePort))
+            {
+                port = commandLinePort;
+            }
+
+            if (!forceOverrideCommandLineArgs && ParseCommandLineOptionsAddress(out var commandLineIp))
+            {
+                ipv4Address = commandLineIp;
+            }
+
             ConnectionData = new ConnectionAddressData
             {
                 Address = ipv4Address,
@@ -1566,6 +1623,11 @@ protected override string GetDisconnectEventMessage(DisconnectEvents disconnectE
             return m_UnityTransportNotificationHandler.GetDisconnectEventMessage(disconnectEvent);
         }
 
+        /// <summary>
+        /// This is set in <see cref="SetConnectionData(string, ushort, string, bool)"/>
+        /// </summary>
+        private bool m_HasForcedConnectionData;
+
         /// <summary>
         /// Initializes the transport
         /// </summary>
@@ -1579,12 +1641,23 @@ public override void Initialize(NetworkManager networkManager = null)
                 return;
             }
 #endif
-
             m_NetworkManager = networkManager;
 
-            if (m_NetworkManager && m_NetworkManager.PortOverride.Overidden)
+            //If the port doesn't have a forced value and is set by a command line option, override it.
+            if (!m_HasForcedConnectionData && ParseCommandLineOptionsAddress(out var portAsString))
             {
-                ConnectionData.Port = m_NetworkManager.PortOverride.Value;
+                if (m_NetworkManager?.LogLevel <= LogLevel.Developer)
+                {
+                    Debug.Log($"The port is set by a command line option. Using following connection data: {ConnectionData.Address}:{portAsString}");
+                }
+                if (ushort.TryParse(portAsString, out ushort port))
+                {
+                    ConnectionData.Port = port;
+                }
+                else
+                {
+                    Debug.LogError($"The port ({portAsString}) is not a valid unsigned short value!");
+                }
             }
 
             m_RealTimeProvider = m_NetworkManager ? m_NetworkManager.RealTimeProvider : new RealTimeProvider();

com.unity.netcode.gameobjects/Runtime/Transports/UTP/UnityTransport.cs

@@ -2,7 +2,7 @@
     "name": "com.unity.netcode.gameobjects",
     "displayName": "Netcode for GameObjects",
     "description": "Netcode for GameObjects is a high-level netcode SDK that provides networking capabilities to GameObject/MonoBehaviour workflows within Unity and sits on top of underlying transport layer.",
-    "version": "2.8.0",
+    "version": "2.9.0",
     "unity": "6000.0",
     "dependencies": {
         "com.unity.nuget.mono-cecil": "1.11.4",