Merge branch 'develop-2.0.0' into fix/server-sending-disconnectmessage-to-self

Author: NoelStephensUnity

com.unity.netcode.gameobjects/CHANGELOG.md

@@ -11,7 +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
 
@@ -25,11 +26,12 @@ Additional documentation and release notes are available at [Multiplayer Documen
 
 ### Fixed
 
+- Fixed issues with the "Client-server quickstart for Netcode for GameObjects" script having static methods and properties. (#3787)
 - Fixed issue where a warning message was being logged upon a client disconnecting from a server when the log level is set to developer. (#3786)
 - Fixed issue where the server or host would no longer have access to the transport id to client id table when processing a transport level client disconnect event. (#3786)
 - 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/Documentation~/tutorials/get-started-with-ngo.md

@@ -142,16 +142,20 @@ using UnityEngine;
 
 namespace HelloWorld
 {
+    /// <summary>
+    /// Add this component to the same GameObject as
+    /// the NetworkManager component.
+    /// </summary>
     public class HelloWorldManager : MonoBehaviour
     {
         private NetworkManager m_NetworkManager;
 
-        void Awake()
+        private void Awake()
         {
             m_NetworkManager = GetComponent<NetworkManager>();
         }
 
-        void OnGUI()
+        private void OnGUI()
         {
             GUILayout.BeginArea(new Rect(10, 10, 300, 300));
             if (!m_NetworkManager.IsClient && !m_NetworkManager.IsServer)
@@ -168,14 +172,14 @@ namespace HelloWorld
             GUILayout.EndArea();
         }
 
-        static void StartButtons()
+        private void StartButtons()
         {
             if (GUILayout.Button("Host")) m_NetworkManager.StartHost();
             if (GUILayout.Button("Client")) m_NetworkManager.StartClient();
             if (GUILayout.Button("Server")) m_NetworkManager.StartServer();
         }
 
-        static void StatusLabels()
+        private void StatusLabels()
         {
             var mode = m_NetworkManager.IsHost ?
                 "Host" : m_NetworkManager.IsServer ? "Server" : "Client";
@@ -185,11 +189,11 @@ namespace HelloWorld
             GUILayout.Label("Mode: " + mode);
         }
 
-        static void SubmitNewPosition()
+        private void SubmitNewPosition()
         {
             if (GUILayout.Button(m_NetworkManager.IsServer ? "Move" : "Request Position Change"))
             {
-                if (m_NetworkManager.IsServer && !m_NetworkManager.IsClient )
+                if (m_NetworkManager.IsServer && !m_NetworkManager.IsClient)
                 {
                     foreach (ulong uid in m_NetworkManager.ConnectedClientsIds)
                         m_NetworkManager.SpawnManager.GetPlayerNetworkObject(uid).GetComponent<HelloWorldPlayer>().Move();
@@ -215,14 +219,14 @@ In your Hello World project, you created a NetworkManager by adding the pre-crea
 The `HelloWorldManager.cs` script accomplishes this menu within the `StartButtons().` After you select a button, the `StatusLabels()`method adds a label on-screen to display which mode you have selected. This helps distinguish Game view windows from each other when testing your multiplayer game.
 
 ```csharp
-       static void StartButtons()
+       private void StartButtons()
         {
             if (GUILayout.Button("Host")) NetworkManager.Singleton.StartHost();
             if (GUILayout.Button("Client")) NetworkManager.Singleton.StartClient();
             if (GUILayout.Button("Server")) NetworkManager.Singleton.StartServer();
         }
 
-        static void StatusLabels()
+        private void StatusLabels()
         {
             var mode = NetworkManager.Singleton.IsHost ?
                 "Host" : NetworkManager.Singleton.IsServer ? "Server" : "Client";
@@ -274,7 +278,7 @@ public class RpcTest : NetworkBehaviour
     }
 
     [Rpc(SendTo.ClientsAndHost)]
-    void ClientAndHostRpc(int value, ulong sourceNetworkObjectId)
+    private void ClientAndHostRpc(int value, ulong sourceNetworkObjectId)
     {
         Debug.Log($"Client Received the RPC #{value} on NetworkObject #{sourceNetworkObjectId}");
         if (IsOwner) //Only send an RPC to the owner of the NetworkObject
@@ -284,7 +288,7 @@ public class RpcTest : NetworkBehaviour
     }
 
     [Rpc(SendTo.Server)]
-    void ServerOnlyRpc(int value, ulong sourceNetworkObjectId)
+    private void ServerOnlyRpc(int value, ulong sourceNetworkObjectId)
     {
         Debug.Log($"Server Received the RPC #{value} on NetworkObject #{sourceNetworkObjectId}");
         ClientAndHostRpc(value, sourceNetworkObjectId);
@@ -375,7 +379,7 @@ namespace HelloWorld
         }
 
         [Rpc(SendTo.Server)]
-        void SubmitPositionRequestRpc(RpcParams rpcParams = default)
+        private void SubmitPositionRequestRpc(RpcParams rpcParams = default)
         {
             var randomPosition = GetRandomPositionOnPlane();
             transform.position = randomPosition;
@@ -387,7 +391,7 @@ namespace HelloWorld
             return new Vector3(Random.Range(-3f, 3f), 1f, Random.Range(-3f, 3f));
         }
 
-        void Update()
+        private void Update()
         {
             transform.position = Position.Value;
         }
@@ -408,7 +412,7 @@ public class HelloWorldPlayer : NetworkBehaviour
 For multiplayer games, every object runs on at least two machines: player one and player two. Because of this, you need to ensure both machines have the same behavior and have the correct information about the object. One of the instances that come into play then is to understand how the Player moves. Only one player controls how the Player object moves. The following code enforces this by validating if the machine running the code is the player's owner.
 
 ```csharp
-       public override void OnNetworkSpawn()
+        public override void OnNetworkSpawn()
         {
             if (IsOwner)
             {
@@ -430,14 +434,14 @@ If the current player is the server, the code determines a random position to sp
         }
 
         [Rpc(SendTo.Server)]
-        void SubmitPositionRequestRpc(RpcParams rpcParams = default)
+        private void SubmitPositionRequestRpc(RpcParams rpcParams = default)
         {
             var randomPosition = GetRandomPositionOnPlane();
             transform.position = randomPosition;
             Position.Value = randomPosition;
         }
 
-        void Update()
+        private void Update()
         {
             transform.position = Position.Value;
         }
@@ -458,8 +462,8 @@ You can call this `Rpc` when the player is a client or a server. When you call a
 The `Rpc` sets the position NetworkVariable on the server's instance of the player by just picking a random point on the plane.
 
 ```csharp
-       [Rpc(SendTo.Server)]
-        void SubmitPositionRequestRpc(RpcParams rpcParams = default)
+        [Rpc(SendTo.Server)]
+        private void SubmitPositionRequestRpc(RpcParams rpcParams = default)
         {
             var randomPosition = GetRandomPositionOnPlane();
             transform.position = randomPosition;
@@ -470,7 +474,7 @@ The `Rpc` sets the position NetworkVariable on the server's instance of the play
 The server instance of the player modifies the `Position` `NetworkVariable` through the `Rpc`. If the player is a client, it must apply the position locally inside the `Update` loop. (Since the two values are the same on the server, the server can run the same logic with no side effects, but you could also add `if(IsClient)` here.)
 
 ```csharp
-       void Update()
+        private void Update()
         {
             transform.position = Position.Value;
         }
@@ -479,7 +483,7 @@ The server instance of the player modifies the `Position` `NetworkVariable` thro
 Because the `HelloWorldPlayer.cs` script handles the position NetworkVariable, the `HelloWorldManager.cs` script can define the contents of `SubmitNewPosition()`.
 
 ```csharp
-       static void SubmitNewPosition()
+        private void SubmitNewPosition()
         {
             if (GUILayout.Button(NetworkManager.Singleton.IsServer ? "Move" : "Request Position Change"))
             {
@@ -550,7 +554,7 @@ using UnityEngine;
 
 public class NetworkTransformTest : NetworkBehaviour
 {
-    void Update()
+    private void Update()
     {
         if (IsServer)
         {

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;
+        }
+    }
+}