Mark ServerRpc.RequireOwnership as deprecated

Author: EmandM

com.unity.netcode.gameobjects/Documentation~/advanced-topics/message-system/rpc.md

@@ -204,7 +204,7 @@ There are a few other parameters that can be passed to either the `Rpc` attribut
 | Parameter               | Description                                                  |
 | ----------------------- | ------------------------------------------------------------ |
 | `Delivery`            | Controls whether the delivery is reliable (default) or unreliable.<br /><br />Options: `RpcDelivery.Reliable` or `RpcDelivery.Unreliable`<br />Default: `RpcDelivery.Reliable` |
-| `RequireOwnership`    | If `true`, this RPC throws an exception if invoked by a player that does not own the object. This is in effect for server-to-client, client-to-server, and client-to-client RPCs - i.e., a server-to-client RPC will still fail if the server is not the object's owner.<br /><br />Default: `false` |
+| `InvokePermission`    | Controls how an RPC is allowed to be invoked.<br /><br />Options:<br /> `RpcInvokePermission.Server` - This RPC throws an exception if invoked by a game client that is not the server.<br />`RpcInvokePermission.Owner` - This RPC throws an exception if invoked by a game client that does not own the object.<br />`RpcInvokePermission.Everyone` - This can be invoked by any connected game client.<br />Default: `RpcInvokePermission.Everyone` |
 | `DeferLocal`          | If `true`, RPCs that execute locally will be deferred until the start of the next frame, as if they had been sent over the network. (They will not actually be sent over the network, but will be treated as if they were.) This is useful for mutually recursive RPCs on hosts, where sending back and forth between the server and the "host client" will cause a stack overflow if each RPC is executed instantly; simulating the flow of RPCs between remote client and server enables this flow to work the same in both contexts.<br /><br />Default: `false` |
 | `AllowTargetOverride` | By default, any `SendTo` value other than `SendTo.SpecifiedInParams` is a hard-coded value that cannot be changed. Setting this to `true` allows you to provide an alternate target at runtime, while using the `SendTo` value as a fallback if no runtime value is provided. |
 

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

@@ -145,7 +145,7 @@ This works the same way with dynamically spawned NetworkObjects.
 
 The [synchronization and notification example](#synchronization-and-notification-example) highlights the differences between synchronizing a `NetworkVariable` with newly-joining clients and notifying connected clients when a `NetworkVariable` changes, but it doesn't provide any concrete example usage.
 
-The `OnValueChanged` example shows a simple server-authoritative `NetworkVariable` being used to track the state of a door (that is, open or closed) using a non-ownership-based server RPC. With `RequireOwnership = false` any client can notify the server that it's performing an action on the door. Each time the door is used by a client, the `Door.ToggleServerRpc` is invoked and the server-side toggles the state of the door. When the `Door.State.Value` changes, all connected clients are synchronized to the (new) current `Value` and the `OnStateChanged` method is invoked locally on each client.
+The `OnValueChanged` example shows a simple server-authoritative `NetworkVariable` being used to track the state of a door (that is, open or closed) using an RPC that is sent to the server. Each time the door is used by a client, the `Door.ToggleServerRpc` is invoked and the server-side toggles the state of the door. When the `Door.State.Value` changes, all connected clients are synchronized to the (new) current `Value` and the `OnStateChanged` method is invoked locally on each client.
 
 ```csharp
 public class Door : NetworkBehaviour

com.unity.netcode.gameobjects/Documentation~/terms-concepts/ownership.md

@@ -8,7 +8,7 @@ Netcode for GameObjects also supports building games with a [distributed authori
 
 ## Ownership in client-server
 
-In a client-server topology, the server has ultimate authority over all NetworkObjects. Clients can request ownership of [specific objects](../components/core/networkobject.md#ownership), but the server has the final say in whether to grant or deny these requests.
+In a client-server topology, the server has ultimate authority over all NetworkObjects. Clients can request ownership of [specific objects](../components/core/networkobject.md#ownership), but the server has the final say in whether to grant or deny these requests.x
 
 ## Ownership in distributed authority
 
@@ -58,4 +58,4 @@ When requesting ownership of a NetworkObject using [`NetworkObject.RequestOwners
 
 * [Authority](authority.md)
 * [Client-server](client-server.md)
-* [Distributed authority](distributed-authority.md)
+* [Distributed authority](distributed-authority.md)

com.unity.netcode.gameobjects/Editor/CodeGen/NetworkBehaviourILPP.cs

@@ -610,7 +610,12 @@ private void CreateNetworkVariableTypeInitializers(AssemblyDefinition assembly,
 
         private const string k_RpcAttribute_Delivery = nameof(RpcAttribute.Delivery);
         private const string k_RpcAttribute_InvokePermission = nameof(RpcAttribute.InvokePermission);
+
+#pragma warning disable CS0618 // Type or member is obsolete
+// Need to ignore the obsolete warning as the obsolete behaviour still needs to work
         private const string k_ServerRpcAttribute_RequireOwnership = nameof(ServerRpcAttribute.RequireOwnership);
+#pragma warning restore CS0618 // Type or member is obsolete
+
         private const string k_RpcParams_Server = nameof(__RpcParams.Server);
         private const string k_RpcParams_Client = nameof(__RpcParams.Client);
         private const string k_RpcParams_Ext = nameof(__RpcParams.Ext);

com.unity.netcode.gameobjects/Runtime/Messaging/RpcAttributes.cs

@@ -129,6 +129,22 @@ public class ServerRpcAttribute : RpcAttribute
         /// When true, only the owner of the NetworkObject can invoke this ServerRpc.
         /// This property sets the base <see cref="RpcAttribute.InvokePermission"/> to <see cref="RpcInvokePermission.Owner"/> when "RequireOwnership = true" or to  <see cref="RpcInvokePermission.Everyone"/> when "RequireOwnership = false". />.
         /// </summary>
+        /// <remarks>
+        /// Deprecated in favor of using <see cref="RpcAttribute"/> with <see cref="SendTo.Server"/> and an <see cref="RpcAttribute.InvokePermission"/>.
+        /// <code>
+        ///     [ServerRpc(RequireOwnership = false)]
+        ///     // is replaced with
+        ///     [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)]
+        ///     // or, as InvokePermission has a default setting of RpcInvokePermission.Everyone, you can also use
+        ///     [Rpc(SendTo.Server)]
+        /// </code>
+        /// <code>
+        ///     [ServerRpc(RequireOwnership = true)]
+        ///     // is replaced with
+        ///     [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Owner)]
+        /// </code>
+        /// </remarks>
+        [Obsolete("ServerRpc with RequireOwnership is deprecated. Use [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Everyone)] or [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Owner)] instead.)]")]
         public new bool RequireOwnership;
 
         /// <summary>

com.unity.netcode.gameobjects/Tests/Editor/NetworkBehaviourEditorTests.cs

@@ -35,6 +35,8 @@ public void AccessNetworkObjectTest()
             var gameObject = new GameObject(nameof(AccessNetworkObjectTest));
             var networkBehaviour = gameObject.AddComponent<EmptyNetworkBehaviour>();
 
+            networkBehaviour.NoNetworkRpc();
+
             Assert.That(networkBehaviour.NetworkObject, Is.Null);
 
             var networkObject = gameObject.AddComponent<NetworkObject>();
@@ -77,6 +79,11 @@ internal class DerivedNetworkBehaviour : EmptyNetworkBehaviour
 
         internal class EmptyNetworkBehaviour : NetworkBehaviour
         {
+            [Rpc(SendTo.Everyone)]
+            public void NoNetworkRpc()
+            {
+                Debug.Log("No Network Rpc");
+            }
         }
     }
 }

com.unity.netcode.gameobjects/Tests/Runtime/NetworkTransform/NetworkTransformParentingTests.cs

@@ -99,8 +99,8 @@ public override void OnNetworkSpawn()
             /// A ServerRpc that requests the server to spawn a player object for the client that invoked this RPC.
             /// </summary>
             /// <param name="rpcParams">Parameters for the ServerRpc, including the sender's client ID.</param>
-            [ServerRpc(RequireOwnership = false)]
-            private void RequestPlayerObjectSpawnServerRpc(ServerRpcParams rpcParams = default)
+            [Rpc(SendTo.Server)]
+            private void RequestPlayerObjectSpawnServerRpc(RpcParams rpcParams = default)
             {
                 SpawnedPlayer = Instantiate(PlayerPrefab);
                 SpawnedPlayer.SpawnAsPlayerObject(rpcParams.Receive.SenderClientId);

com.unity.netcode.gameobjects/Tests/Runtime/Rpc/RpcManyClientsTests.cs

@@ -11,33 +11,33 @@ internal class RpcManyClientsObject : NetworkBehaviour
     {
         public int Count = 0;
         public List<ulong> ReceivedFrom = new List<ulong>();
-        [ServerRpc(RequireOwnership = false)]
-        public void ResponseServerRpc(ServerRpcParams rpcParams = default)
+        [Rpc(SendTo.Server)]
+        public void ResponseServerRpc(RpcParams rpcParams = default)
         {
             ReceivedFrom.Add(rpcParams.Receive.SenderClientId);
             Count++;
         }
 
-        [ClientRpc]
+        [Rpc(SendTo.ClientsAndHost)]
         public void NoParamsClientRpc()
         {
             ResponseServerRpc();
         }
 
-        [ClientRpc]
+        [Rpc(SendTo.ClientsAndHost)]
         public void OneParamClientRpc(int value)
         {
             ResponseServerRpc();
         }
 
-        [ClientRpc]
+        [Rpc(SendTo.ClientsAndHost)]
         public void TwoParamsClientRpc(int value1, int value2)
         {
             ResponseServerRpc();
         }
 
-        [ClientRpc]
-        public void WithParamsClientRpc(ClientRpcParams param)
+        [Rpc(SendTo.SpecifiedInParams)]
+        public void WithParamsClientRpc(RpcParams param)
         {
             ResponseServerRpc();
         }
@@ -114,7 +114,7 @@ public void RpcManyClientsTest()
             success = WaitForConditionOrTimeOutWithTimeTravel(() => TotalClients == rpcManyClientsObject.Count);
             Assert.True(success, $"Timed out wait for {nameof(rpcManyClientsObject.OneParamClientRpc)}! Only {rpcManyClientsObject.Count} of {TotalClients} was received!");
 
-            var param = new ClientRpcParams();
+            var param = new RpcParams();
 
             rpcManyClientsObject.Count = 0;
             rpcManyClientsObject.TwoParamsClientRpc(0, 0); // RPC with two params
@@ -127,8 +127,8 @@ public void RpcManyClientsTest()
 
             rpcManyClientsObject.ReceivedFrom.Clear();
             rpcManyClientsObject.Count = 0;
-            var target = new List<ulong> { m_ClientNetworkManagers[1].LocalClientId, m_ClientNetworkManagers[2].LocalClientId };
-            param.Send.TargetClientIds = target;
+            var target = new [] { m_ClientNetworkManagers[1].LocalClientId, m_ClientNetworkManagers[2].LocalClientId };
+            param.Send.Target = rpcManyClientsObject.RpcTarget.Group(target, RpcTargetUse.Temp);
             rpcManyClientsObject.WithParamsClientRpc(param);
 
             messageHookList.Clear();

com.unity.netcode.gameobjects/Tests/Runtime/Rpc/UniversalRpcTests.cs

@@ -432,70 +432,70 @@ public void DefaultToNotAuthorityDeferLocalRpc(RpcParams rpcParams)
         {
             OnRpcReceived();
         }
-        
-        // RPCs with RequireOwnership = true
 
-        [Rpc(SendTo.Everyone, RequireOwnership = true)]
+        // RPCs with InvokePermission.Owner
+
+        [Rpc(SendTo.Everyone, InvokePermission = RpcInvokePermission.Owner)]
         public void DefaultToEveryoneRequireOwnershipRpc()
         {
             OnRpcReceived();
         }
 
-        [Rpc(SendTo.Me, RequireOwnership = true)]
+        [Rpc(SendTo.Me, InvokePermission = RpcInvokePermission.Owner)]
         public void DefaultToMeRequireOwnershipRpc()
         {
             OnRpcReceived();
         }
 
-        [Rpc(SendTo.Owner, RequireOwnership = true)]
+        [Rpc(SendTo.Owner, InvokePermission = RpcInvokePermission.Owner)]
         public void DefaultToOwnerRequireOwnershipRpc()
         {
             OnRpcReceived();
         }
 
-        [Rpc(SendTo.NotOwner, RequireOwnership = true)]
+        [Rpc(SendTo.NotOwner, InvokePermission = RpcInvokePermission.Owner)]
         public void DefaultToNotOwnerRequireOwnershipRpc()
         {
             OnRpcReceived();
         }
 
-        [Rpc(SendTo.Server, RequireOwnership = true)]
+        [Rpc(SendTo.Server, InvokePermission = RpcInvokePermission.Owner)]
         public void DefaultToServerRequireOwnershipRpc()
         {
             OnRpcReceived();
         }
 
-        [Rpc(SendTo.NotMe, RequireOwnership = true)]
+        [Rpc(SendTo.NotMe, InvokePermission = RpcInvokePermission.Owner)]
         public void DefaultToNotMeRequireOwnershipRpc()
         {
             OnRpcReceived();
         }
 
-        [Rpc(SendTo.NotServer, RequireOwnership = true)]
+        [Rpc(SendTo.NotServer, InvokePermission = RpcInvokePermission.Owner)]
         public void DefaultToNotServerRequireOwnershipRpc()
         {
             OnRpcReceived();
         }
 
-        [Rpc(SendTo.ClientsAndHost, RequireOwnership = true)]
+        [Rpc(SendTo.ClientsAndHost, InvokePermission = RpcInvokePermission.Owner)]
         public void DefaultToClientsAndHostRequireOwnershipRpc()
         {
             OnRpcReceived();
         }
 
-        [Rpc(SendTo.SpecifiedInParams, RequireOwnership = true)]
+        [Rpc(SendTo.SpecifiedInParams, InvokePermission = RpcInvokePermission.Owner)]
         public void SpecifiedInParamsRequireOwnershipRpc(RpcParams rpcParams)
         {
             OnRpcReceived();
         }
 
-        [Rpc(SendTo.Authority, RequireOwnership = true)]
+        [Rpc(SendTo.Authority, InvokePermission = RpcInvokePermission.Owner)]
         public void DefaultToAuthorityRequireOwnershipRpc()
         {
             OnRpcReceived();
         }
 
-        [Rpc(SendTo.NotAuthority, RequireOwnership = true)]
+        [Rpc(SendTo.NotAuthority, InvokePermission = RpcInvokePermission.Owner)]
         public void DefaultToNotAuthorityRequireOwnershipRpc()
         {
             OnRpcReceived();

testproject/Assets/Samples/SpawnObject/SpawnObjectHandler.cs

@@ -65,8 +65,8 @@ private void AutoSpawnObject(ulong ownerId, int selection)
         SetMotion(networkObject.gameObject);
     }
 
-    [ServerRpc(RequireOwnership = false)]
-    private void AutoSpawnObjectServerRpc(int selection, ServerRpcParams serverRpcParams = default)
+    [Rpc(SendTo.Server)]
+    private void AutoSpawnObjectServerRpc(int selection, RpcParams serverRpcParams = default)
     {
         AutoSpawnObject(serverRpcParams.Receive.SenderClientId, selection);
     }
@@ -88,8 +88,8 @@ public void AutoSpawnClick()
         }
     }
 
-    [ServerRpc(RequireOwnership = false)]
-    private void ManualSpawnObjectServerRpc(int selection, ServerRpcParams serverRpcParams = default)
+    [Rpc(SendTo.Server)]
+    private void ManualSpawnObjectServerRpc(int selection, RpcParams serverRpcParams = default)
     {
         AutoSpawnObject(serverRpcParams.Receive.SenderClientId, selection);
     }