com.unity.netcode.gameobjects@2.0.0-exp.2

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). ## [2.0.0-exp.2] - 2024-04-02 ### Added - Added updates to all internal messages to account for a distributed authority network session connection. (#2863) - Added `NetworkRigidbodyBase` that provides users with a more customizable network rigidbody, handles both `Rigidbody` and `Rigidbody2D`, and provides an option to make `NetworkTransform` use the rigid body for motion. (#2863) - For a customized `NetworkRigidbodyBase` class: - `NetworkRigidbodyBase.AutoUpdateKinematicState` provides control on whether the kinematic setting will be automatically set or not when ownership changes. - `NetworkRigidbodyBase.AutoSetKinematicOnDespawn` provides control on whether isKinematic will automatically be set to true when the associated `NetworkObject` is despawned. - `NetworkRigidbodyBase.Initialize` is a protected method that, when invoked, will initialize the instance. This includes options to: - Set whether using a `RigidbodyTypes.Rigidbody` or `RigidbodyTypes.Rigidbody2D`. - Includes additional optional parameters to set the `NetworkTransform`, `Rigidbody`, and `Rigidbody2d` to use. - Provides additional public methods: - `NetworkRigidbodyBase.GetPosition` to return the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting). - `NetworkRigidbodyBase.GetRotation` to return the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting). - `NetworkRigidbodyBase.MovePosition` to move to the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting). - `NetworkRigidbodyBase.MoveRotation` to move to the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting). - `NetworkRigidbodyBase.Move` to move to the position and rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting). - `NetworkRigidbodyBase.Move` to move to the position and rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting). - `NetworkRigidbodyBase.SetPosition` to set the position of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting). - `NetworkRigidbodyBase.SetRotation` to set the rotation of the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting). - `NetworkRigidbodyBase.ApplyCurrentTransform` to set the position and rotation of the `Rigidbody` or `Rigidbody2d` based on the associated `GameObject` transform (depending upon its initialized setting). - `NetworkRigidbodyBase.WakeIfSleeping` to wake up the rigid body if sleeping. - `NetworkRigidbodyBase.SleepRigidbody` to put the rigid body to sleep. - `NetworkRigidbodyBase.IsKinematic` to determine if the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) is currently kinematic. - `NetworkRigidbodyBase.SetIsKinematic` to set the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) current kinematic state. - `NetworkRigidbodyBase.ResetInterpolation` to reset the `Rigidbody` or `Rigidbody2d` (depending upon its initialized setting) back to its original interpolation value when initialized. - Now includes a `MonoBehaviour.FixedUpdate` implementation that will update the assigned `NetworkTransform` when `NetworkRigidbodyBase.UseRigidBodyForMotion` is true. (#2863) - Added `RigidbodyContactEventManager` that provides a more optimized way to process collision enter and collision stay events as opposed to the `Monobehaviour` approach. (#2863) - Can be used in client-server and distributed authority modes, but is particularly useful in distributed authority. - Added rigid body motion updates to `NetworkTransform` which allows users to set interolation on rigid bodies. (#2863) - Extrapolation is only allowed on authoritative instances, but custom class derived from `NetworkRigidbodyBase` or `NetworkRigidbody` or `NetworkRigidbody2D` automatically switches non-authoritative instances to interpolation if set to extrapolation. - Added distributed authority mode support to `NetworkAnimator`. (#2863) - Added session mode selection to `NetworkManager` inspector view. (#2863) - Added distributed authority permissions feature. (#2863) - Added distributed authority mode specific `NetworkObject` permissions flags (Distributable, Transferable, and RequestRequired). (#2863) - Added distributed authority mode specific `NetworkObject.SetOwnershipStatus` method that applies one or more `NetworkObject` instance's ownership flags. If updated when spawned, the ownership permission changes are synchronized with the other connected clients. (#2863) - Added distributed authority mode specific `NetworkObject.RemoveOwnershipStatus` method that removes one or more `NetworkObject` instance's ownership flags. If updated when spawned, the ownership permission changes are synchronized with the other connected clients. (#2863) - Added distributed authority mode specific `NetworkObject.HasOwnershipStatus` method that will return (true or false) whether one or more ownership flags is set. (#2863) - Added distributed authority mode specific `NetworkObject.SetOwnershipLock` method that locks ownership of a `NetworkObject` to prevent ownership from changing until the current owner releases the lock. (#2863) - Added distributed authority mode specific `NetworkObject.RequestOwnership` method that sends an ownership request to the current owner of a spawned `NetworkObject` instance. (#2863) - Added distributed authority mode specific `NetworkObject.OnOwnershipRequested` callback handler that is invoked on the owner/authoritative side when a non-owner requests ownership. Depending upon the boolean returned value depends upon whether the request is approved or denied. (#2863) - Added distributed authority mode specific `NetworkObject.OnOwnershipRequestResponse` callback handler that is invoked when a non-owner's request has been processed. This callback includes a `NetworkObjet.OwnershipRequestResponseStatus` response parameter that describes whether the request was approved or the reason why it was not approved. (#2863) - Added distributed authority mode specific `NetworkObject.DeferDespawn` method that defers the despawning of `NetworkObject` instances on non-authoritative clients based on the tick offset parameter. (#2863) - Added distributed authority mode specific `NetworkObject.OnDeferredDespawnComplete` callback handler that can be used to further control when deferring the despawning of a `NetworkObject` on non-authoritative instances. (#2863) - Added `NetworkClient.SessionModeType` as one way to determine the current session mode of the network session a client is connected to. (#2863) - Added distributed authority mode specific `NetworkClient.IsSessionOwner` property to determine if the current local client is the current session owner of a distributed authority session. (#2863) - Added distributed authority mode specific client side spawning capabilities. When running in distributed authority mode, clients can instantiate and spawn `NetworkObject` instances (the local client is authomatically the owner of the spawned object). (#2863) - This is useful to better visually synchronize owner authoritative motion models and newly spawned `NetworkObject` instances (i.e. projectiles for example). - Added distributed authority mode specific client side player spawning capabilities. Clients will automatically spawn their associated player object locally. (#2863) - Added distributed authority mode specific `NetworkConfig.AutoSpawnPlayerPrefabClientSide` property (default is true) to provide control over the automatic spawning of player prefabs on the local client side. (#2863) - Added distributed authority mode specific `NetworkManager.OnFetchLocalPlayerPrefabToSpawn` callback that, when assigned, will allow the local client to provide the player prefab to be spawned for the local client. (#2863) - This is only invoked if the `NetworkConfig.AutoSpawnPlayerPrefabClientSide` property is set to true. - Added distributed authority mode specific `NetworkBehaviour.HasAuthority` property that determines if the local client has authority over the associated `NetworkObject` instance (typical use case is within a `NetworkBehaviour` script much like that of `IsServer` or `IsClient`). (#2863) - Added distributed authority mode specific `NetworkBehaviour.IsSessionOwner` property that determines if the local client is the session owner (typical use case would be to determine if the local client can has scene management authority within a `NetworkBehaviour` script). (#2863) - Added support for distributed authority mode scene management where the currently assigned session owner can start scene events (i.e. scene loading and scene unloading). (#2863) ### Fixed - Fixed issue where the host was not invoking `OnClientDisconnectCallback` for its own local client when internally shutting down. (#2822) - Fixed issue where NetworkTransform could potentially attempt to "unregister" a named message prior to it being registered. (#2807) - Fixed issue where in-scene placed `NetworkObject`s with complex nested children `NetworkObject`s (more than one child in depth) would not synchronize properly if WorldPositionStays was set to true. (#2796) ### Changed - Changed client side awareness of other clients is now the same as a server or host. (#2863) - Changed `NetworkManager.ConnectedClients` can now be accessed by both server and clients. (#2863) - Changed `NetworkManager.ConnectedClientsList` can now be accessed by both server and clients. (#2863) - Changed `NetworkTransform` defaults to owner authoritative when connected to a distributed authority session. (#2863) - Changed `NetworkVariable` defaults to owner write and everyone read permissions when connected to a distributed authority session (even if declared with server read or write permissions). (#2863) - Changed `NetworkObject` no longer implements the `MonoBehaviour.Update` method in order to determine whether a `NetworkObject` instance has been migrated to a different scene. Instead, only `NetworkObjects` with the `SceneMigrationSynchronization` property set will be updated internally during the `NetworkUpdateStage.PostLateUpdate` by `NetworkManager`. (#2863) - Changed `NetworkManager` inspector view layout where properties are now organized by category. (#2863) - Changed `NetworkTransform` to now use `NetworkTransformMessage` as opposed to named messages for NetworkTransformState updates. (#2810) - Changed `CustomMessageManager` so it no longer attempts to register or "unregister" a null or empty string and will log an error if this condition occurs. (#2807)
2024-04-02 00:00:00 +00:00
parent f8ebf679ec
commit 143a6cbd34
140 changed files with 18009 additions and 2672 deletions
--- a/Tests/Runtime/UniversalRpcTests.cs
+++ b/Tests/Runtime/UniversalRpcTests.cs
@@ -1,3 +1,4 @@
+#if !MULTIPLAYER_TOOLS && !NGO_MINIMALPROJECT
 using System;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -24,6 +25,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        public string Received = string.Empty;
        public Tuple<int, bool, float, string> ReceivedParams = null;
        public ulong ReceivedFrom = ulong.MaxValue;
+        public int ReceivedCount;

        public void OnRpcReceived()
        {
@@ -32,6 +34,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests

            var currentMethod = sf.GetMethod();
            Received = currentMethod.Name;
+            ReceivedCount++;
        }
        public void OnRpcReceivedWithParams(int a, bool b, float f, string s)
        {
@@ -40,6 +43,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests

            var currentMethod = sf.GetMethod();
            Received = currentMethod.Name;
+            ReceivedCount++;
            ReceivedParams = new Tuple<int, bool, float, string>(a, b, f, s);
        }

@@ -93,6 +97,18 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            OnRpcReceived();
        }

+        [Rpc(SendTo.Authority)]
+        public void DefaultToAuthorityRpc()
+        {
+            OnRpcReceived();
+        }
+
+        [Rpc(SendTo.NotAuthority)]
+        public void DefaultToNotAuthorityRpc()
+        {
+            OnRpcReceived();
+        }
+
        // RPCs with parameters

        [Rpc(SendTo.Everyone)]
@@ -143,6 +159,18 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            OnRpcReceivedWithParams(i, b, f, s);
        }

+        [Rpc(SendTo.Authority)]
+        public void DefaultToAuthorityWithParamsRpc(int i, bool b, float f, string s)
+        {
+            OnRpcReceivedWithParams(i, b, f, s);
+        }
+
+        [Rpc(SendTo.NotAuthority)]
+        public void DefaultToNotAuthorityWithParamsRpc(int i, bool b, float f, string s)
+        {
+            OnRpcReceivedWithParams(i, b, f, s);
+        }
+
        // RPCs with RPC parameters

        [Rpc(SendTo.Everyone)]
@@ -201,6 +229,19 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            ReceivedFrom = rpcParams.Receive.SenderClientId;
        }

+        [Rpc(SendTo.Authority)]
+        public void DefaultToAuthorityWithRpcParamsRpc(RpcParams rpcParams)
+        {
+            OnRpcReceived();
+            ReceivedFrom = rpcParams.Receive.SenderClientId;
+        }
+
+        [Rpc(SendTo.NotAuthority)]
+        public void DefaultToNotAuthorityWithRpcParamsRpc(RpcParams rpcParams)
+        {
+            OnRpcReceived();
+            ReceivedFrom = rpcParams.Receive.SenderClientId;
+        }

        // RPCs with parameters and RPC parameters

@@ -252,6 +293,18 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            OnRpcReceivedWithParams(i, b, f, s);
        }

+        [Rpc(SendTo.Authority)]
+        public void DefaultToAuthorityWithParamsAndRpcParamsRpc(int i, bool b, float f, string s, RpcParams rpcParams)
+        {
+            OnRpcReceivedWithParams(i, b, f, s);
+        }
+
+        [Rpc(SendTo.NotAuthority)]
+        public void DefaultToNotAuthorityWithParamsAndRpcParamsRpc(int i, bool b, float f, string s, RpcParams rpcParams)
+        {
+            OnRpcReceivedWithParams(i, b, f, s);
+        }
+
        // RPCs with AllowTargetOverride = true

        // AllowTargetOverried is implied with SpecifiedInParams and does not need to be stated
@@ -310,6 +363,18 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            OnRpcReceived();
        }

+        [Rpc(SendTo.Authority, AllowTargetOverride = true)]
+        public void DefaultToAuthorityAllowOverrideRpc(RpcParams rpcParams)
+        {
+            OnRpcReceived();
+        }
+
+        [Rpc(SendTo.NotAuthority, AllowTargetOverride = true)]
+        public void DefaultToNotAuthorityAllowOverrideRpc(RpcParams rpcParams)
+        {
+            OnRpcReceived();
+        }
+
        // RPCs with DeferLocal = true

        [Rpc(SendTo.Everyone, DeferLocal = true)]
@@ -354,6 +419,18 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            OnRpcReceived();
        }

+        [Rpc(SendTo.Authority, DeferLocal = true)]
+        public void DefaultToAuthorityDeferLocalRpc(RpcParams rpcParams)
+        {
+            OnRpcReceived();
+        }
+
+        [Rpc(SendTo.NotAuthority, DeferLocal = true)]
+        public void DefaultToNotAuthorityDeferLocalRpc(RpcParams rpcParams)
+        {
+            OnRpcReceived();
+        }
+
        // RPCs with RequireOwnership = true

        [Rpc(SendTo.Everyone, RequireOwnership = true)]
@@ -410,6 +487,17 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            OnRpcReceived();
        }

+        [Rpc(SendTo.Authority, RequireOwnership = true)]
+        public void DefaultToAuthorityRequireOwnershipRpc()
+        {
+            OnRpcReceived();
+        }
+
+        [Rpc(SendTo.NotAuthority, RequireOwnership = true)]
+        public void DefaultToNotAuthorityRequireOwnershipRpc()
+        {
+            OnRpcReceived();
+        }

        // Mutual RPC Recursion

@@ -496,6 +584,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            foreach (var obj in Object.FindObjectsByType<UniversalRpcNetworkBehaviour>(FindObjectsSortMode.None))
            {
                obj.Received = string.Empty;
+                obj.ReceivedCount = 0;
                obj.ReceivedParams = null;
                obj.ReceivedFrom = ulong.MaxValue;
            }
@@ -528,10 +617,11 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            return m_PlayerNetworkObjects[onClient][ownerClientId].GetComponent<UniversalRpcNetworkBehaviour>();
        }

-        protected void VerifyLocalReceived(ulong objectOwner, ulong sender, string name, bool verifyReceivedFrom)
+        protected void VerifyLocalReceived(ulong objectOwner, ulong sender, string name, bool verifyReceivedFrom, int expectedReceived = 1)
        {
            var obj = GetPlayerObject(objectOwner, sender);
            Assert.AreEqual(name, obj.Received);
+            Assert.That(obj.ReceivedCount, Is.EqualTo(expectedReceived));
            Assert.IsNull(obj.ReceivedParams);
            if (verifyReceivedFrom)
            {
@@ -543,6 +633,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        {
            var obj = GetPlayerObject(objectOwner, sender);
            Assert.AreEqual(name, obj.Received);
+            Assert.That(obj.ReceivedCount, Is.EqualTo(1));
            Assert.IsNotNull(obj.ReceivedParams);
            Assert.AreEqual(i, obj.ReceivedParams.Item1);
            Assert.AreEqual(b, obj.ReceivedParams.Item2);
@@ -556,17 +647,18 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            {
                UniversalRpcNetworkBehaviour playerObject = GetPlayerObject(objectOwner, client);
                Assert.AreEqual(string.Empty, playerObject.Received);
+                Assert.That(playerObject.ReceivedCount, Is.EqualTo(0));
                Assert.IsNull(playerObject.ReceivedParams);
            }
        }

-        protected void VerifyRemoteReceived(ulong objectOwner, ulong sender, string message, ulong[] receivedBy, bool verifyReceivedFrom, bool waitForMessages = true)
+        protected void VerifyRemoteReceived(ulong objectOwner, ulong sender, string message, ulong[] receivedBy, bool verifyReceivedFrom, bool waitForMessages = true, int expectedReceived = 1)
        {
            foreach (var client in receivedBy)
            {
                if (client == sender)
                {
-                    VerifyLocalReceived(objectOwner, sender, message, verifyReceivedFrom);
+                    VerifyLocalReceived(objectOwner, sender, message, verifyReceivedFrom, expectedReceived);

                    break;
                }
@@ -628,6 +720,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            {
                UniversalRpcNetworkBehaviour playerObject = GetPlayerObject(objectOwner, client);
                Assert.AreEqual(message, playerObject.Received);
+                Assert.That(playerObject.ReceivedCount, Is.EqualTo(expectedReceived));
                Assert.IsNull(playerObject.ReceivedParams);
                if (verifyReceivedFrom)
                {
@@ -701,6 +794,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            {
                UniversalRpcNetworkBehaviour playerObject = GetPlayerObject(objectOwner, client);
                Assert.AreEqual(message, playerObject.Received);
+                Assert.That(playerObject.ReceivedCount, Is.EqualTo(1));

                Assert.IsNotNull(playerObject.ReceivedParams);
                Assert.AreEqual(i, playerObject.ReceivedParams.Item1);
@@ -805,6 +899,26 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            VerifySentToNotId(objectOwner, sender, sender, methodName, false);
        }

+        public void VerifySentToAuthority(ulong objectOwner, ulong sender, string methodName)
+        {
+            var receiver = objectOwner;
+            if (!m_DistributedAuthority)
+            {
+                receiver = NetworkManager.ServerClientId;
+            }
+            VerifySentToId(objectOwner, sender, receiver, methodName, false);
+        }
+
+        public void VerifySentToNotAuthority(ulong objectOwner, ulong sender, string methodName)
+        {
+            var receiver = objectOwner;
+            if (!m_DistributedAuthority)
+            {
+                receiver = NetworkManager.ServerClientId;
+            }
+            VerifySentToNotId(objectOwner, sender, receiver, methodName, false);
+        }
+
        public void VerifySentToOwnerWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
        {
            VerifySentToId(objectOwner, sender, objectOwner, methodName, true);
@@ -847,6 +961,26 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            VerifySentToNotId(objectOwner, sender, sender, methodName, true);
        }

+        public void VerifySentToAuthorityWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
+        {
+            var receiver = objectOwner;
+            if (!m_DistributedAuthority)
+            {
+                receiver = NetworkManager.ServerClientId;
+            }
+            VerifySentToId(objectOwner, sender, receiver, methodName, true);
+        }
+
+        public void VerifySentToNotAuthorityWithReceivedFrom(ulong objectOwner, ulong sender, string methodName)
+        {
+            var receiver = objectOwner;
+            if (!m_DistributedAuthority)
+            {
+                receiver = NetworkManager.ServerClientId;
+            }
+            VerifySentToNotId(objectOwner, sender, receiver, methodName, true);
+        }
+
        public void VerifySentToOwnerWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
        {
            VerifySentToIdWithParams(objectOwner, sender, objectOwner, methodName, i, b, f, s);
@@ -889,6 +1023,26 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
            VerifySentToNotIdWithParams(objectOwner, sender, sender, methodName, i, b, f, s);
        }

+        public void VerifySentToAuthorityWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
+        {
+            var receiver = objectOwner;
+            if (!m_DistributedAuthority)
+            {
+                receiver = NetworkManager.ServerClientId;
+            }
+            VerifySentToIdWithParams(objectOwner, sender, receiver, methodName, i, b, f, s);
+        }
+
+        public void VerifySentToNotAuthorityWithParams(ulong objectOwner, ulong sender, string methodName, int i, bool b, float f, string s)
+        {
+            var receiver = objectOwner;
+            if (!m_DistributedAuthority)
+            {
+                receiver = NetworkManager.ServerClientId;
+            }
+            VerifySentToNotIdWithParams(objectOwner, sender, receiver, methodName, i, b, f, s);
+        }
+
        public void RethrowTargetInvocationException(Action action)
        {
            try
@@ -902,6 +1056,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        }
    }

+    [TestFixture(HostOrServer.DAHost)]
    [TestFixture(HostOrServer.Host)]
    [TestFixture(HostOrServer.Server)]
    internal class UniversalRpcTestSendingNoOverride : UniversalRpcTestsBase
@@ -914,7 +1069,8 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        [Test]
        public void TestSendingNoOverride(
            // Excludes SendTo.SpecifiedInParams
-            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
+            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer,
+            SendTo.ClientsAndHost, SendTo.Authority, SendTo.NotAuthority)] SendTo sendTo,
            [Values(0u, 1u, 2u)] ulong objectOwner,
            [Values(0u, 1u, 2u)] ulong sender
        )
@@ -932,6 +1088,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests

    }

+    [TestFixture(HostOrServer.DAHost)]
    [TestFixture(HostOrServer.Host)]
    [TestFixture(HostOrServer.Server)]
    internal class UniversalRpcTestSenderClientId : UniversalRpcTestsBase
@@ -944,7 +1101,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        [Test]
        public void TestSenderClientId(
            // Excludes SendTo.SpecifiedInParams
-            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
+            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost, SendTo.Authority, SendTo.NotAuthority)] SendTo sendTo,
            [Values(0u, 1u, 2u)] ulong objectOwner,
            [Values(0u, 1u, 2u)] ulong sender
        )
@@ -962,6 +1119,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests

    }

+    [TestFixture(HostOrServer.DAHost)]
    [TestFixture(HostOrServer.Host)]
    [TestFixture(HostOrServer.Server)]
    internal class UniversalRpcTestSendingNoOverrideWithParams : UniversalRpcTestsBase
@@ -974,7 +1132,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        [Test]
        public void TestSendingNoOverrideWithParams(
            // Excludes SendTo.SpecifiedInParams
-            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
+            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost, SendTo.Authority, SendTo.NotAuthority)] SendTo sendTo,
            [Values(0u, 1u, 2u)] ulong objectOwner,
            [Values(0u, 1u, 2u)] ulong sender
        )
@@ -1004,6 +1162,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests

    }

+    [TestFixture(HostOrServer.DAHost)]
    [TestFixture(HostOrServer.Host)]
    [TestFixture(HostOrServer.Server)]
    internal class UniversalRpcTestSendingNoOverrideWithParamsAndRpcParams : UniversalRpcTestsBase
@@ -1016,7 +1175,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        [Test]
        public void TestSendingNoOverrideWithParamsAndRpcParams(
            // Excludes SendTo.SpecifiedInParams
-            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
+            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost, SendTo.Authority, SendTo.NotAuthority)] SendTo sendTo,
            [Values(0u, 1u, 2u)] ulong objectOwner,
            [Values(0u, 1u, 2u)] ulong sender
        )
@@ -1046,6 +1205,8 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests

    }

+
+    [TestFixture(HostOrServer.DAHost)]
    [TestFixture(HostOrServer.Host)]
    [TestFixture(HostOrServer.Server)]
    internal class UniversalRpcTestRequireOwnership : UniversalRpcTestsBase
@@ -1058,7 +1219,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        [Test]
        public void TestRequireOwnership(
            // Excludes SendTo.SpecifiedInParams
-            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
+            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost, SendTo.Authority, SendTo.NotAuthority)] SendTo sendTo,
            [Values(0u, 1u, 2u)] ulong objectOwner,
            [Values(0u, 1u, 2u)] ulong sender
        )
@@ -1082,6 +1243,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        }
    }

+    [TestFixture(HostOrServer.DAHost)]
    [TestFixture(HostOrServer.Host)]
    [TestFixture(HostOrServer.Server)]
    internal class UniversalRpcTestDisallowedOverride : UniversalRpcTestsBase
@@ -1091,10 +1253,11 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests

        }

+        // Add both authority and nonauthority
        [Test]
        public void TestDisallowedOverride(
            // Excludes SendTo.SpecifiedInParams
-            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost)] SendTo sendTo,
+            [Values(SendTo.Everyone, SendTo.Me, SendTo.Owner, SendTo.Server, SendTo.NotMe, SendTo.NotOwner, SendTo.NotServer, SendTo.ClientsAndHost, SendTo.Authority, SendTo.NotAuthority)] SendTo sendTo,
            [Values(0u, 1u, 2u)] ulong objectOwner,
            [Values(0u, 1u, 2u)] ulong sender)
        {
@@ -1126,6 +1289,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests

        }

+        // Look at the implementations and add both
        [Test]
        public void TestSendingWithTargetOverride(
            [Values] SendTo defaultSendTo,
@@ -1382,6 +1546,7 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        }
    }

+    [TestFixture(HostOrServer.DAHost)]
    [TestFixture(HostOrServer.Host)]
    [TestFixture(HostOrServer.Server)]
    internal class UniversalRpcTestDeferLocal : UniversalRpcTestsBase
@@ -1438,6 +1603,15 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        [TestCase(SendTo.ClientsAndHost, 2u, 0u)]
        [TestCase(SendTo.ClientsAndHost, 2u, 1u)]
        [TestCase(SendTo.ClientsAndHost, 2u, 2u)]
+        [TestCase(SendTo.Authority, 0u, 0u)]
+        [TestCase(SendTo.Authority, 1u, 1u)]
+        [TestCase(SendTo.Authority, 2u, 2u)]
+        [TestCase(SendTo.NotAuthority, 0u, 1u)]
+        [TestCase(SendTo.NotAuthority, 0u, 2u)]
+        [TestCase(SendTo.NotAuthority, 1u, 0u)]
+        [TestCase(SendTo.NotAuthority, 1u, 2u)]
+        [TestCase(SendTo.NotAuthority, 2u, 0u)]
+        [TestCase(SendTo.NotAuthority, 2u, 1u)]
        public void TestDeferLocal(
            SendTo defaultSendTo,
            ulong objectOwner,
@@ -1450,6 +1624,13 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
                // Just consider this case a success...
                return;
            }
+
+            // Similar to above, since Server and NotServer are already tested we can consider this a success
+            if (!m_DistributedAuthority && defaultSendTo == SendTo.Authority || defaultSendTo == SendTo.NotAuthority)
+            {
+                return;
+            }
+
            var sendMethodName = $"DefaultTo{defaultSendTo}DeferLocalRpc";
            var verifyMethodName = $"VerifySentTo{defaultSendTo}";
            var senderObject = GetPlayerObject(objectOwner, sender);
@@ -1512,6 +1693,15 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        [TestCase(SendTo.ClientsAndHost, 2u, 0u)]
        [TestCase(SendTo.ClientsAndHost, 2u, 1u)]
        [TestCase(SendTo.ClientsAndHost, 2u, 2u)]
+        [TestCase(SendTo.Authority, 0u, 0u)]
+        [TestCase(SendTo.Authority, 1u, 1u)]
+        [TestCase(SendTo.Authority, 2u, 2u)]
+        [TestCase(SendTo.NotAuthority, 0u, 1u)]
+        [TestCase(SendTo.NotAuthority, 0u, 2u)]
+        [TestCase(SendTo.NotAuthority, 1u, 0u)]
+        [TestCase(SendTo.NotAuthority, 1u, 2u)]
+        [TestCase(SendTo.NotAuthority, 2u, 0u)]
+        [TestCase(SendTo.NotAuthority, 2u, 1u)]
        public void TestDeferLocalOverrideToTrue(
            SendTo defaultSendTo,
            ulong objectOwner,
@@ -1524,6 +1714,12 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
                // Just consider this case a success...
                return;
            }
+            // Similar to above, since Server and NotServer are already tested we can consider this a success
+            if (!m_DistributedAuthority && defaultSendTo == SendTo.Authority || defaultSendTo == SendTo.NotAuthority)
+            {
+                return;
+            }
+
            var sendMethodName = $"DefaultTo{defaultSendTo}WithRpcParamsRpc";
            var verifyMethodName = $"VerifySentTo{defaultSendTo}";
            var senderObject = GetPlayerObject(objectOwner, sender);
@@ -1586,6 +1782,15 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
        [TestCase(SendTo.ClientsAndHost, 2u, 0u)]
        [TestCase(SendTo.ClientsAndHost, 2u, 1u)]
        [TestCase(SendTo.ClientsAndHost, 2u, 2u)]
+        [TestCase(SendTo.Authority, 0u, 0u)]
+        [TestCase(SendTo.Authority, 1u, 1u)]
+        [TestCase(SendTo.Authority, 2u, 2u)]
+        [TestCase(SendTo.NotAuthority, 0u, 1u)]
+        [TestCase(SendTo.NotAuthority, 0u, 2u)]
+        [TestCase(SendTo.NotAuthority, 1u, 0u)]
+        [TestCase(SendTo.NotAuthority, 1u, 2u)]
+        [TestCase(SendTo.NotAuthority, 2u, 0u)]
+        [TestCase(SendTo.NotAuthority, 2u, 1u)]
        public void TestDeferLocalOverrideToFalse(
            SendTo defaultSendTo,
            ulong objectOwner,
@@ -1598,6 +1803,12 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests
                // Just consider this case a success...
                return;
            }
+            // Similar to above, since Server and NotServer are already tested we can consider this a success
+            if (!m_DistributedAuthority && defaultSendTo == SendTo.Authority || defaultSendTo == SendTo.NotAuthority)
+            {
+                return;
+            }
+
            var sendMethodName = $"DefaultTo{defaultSendTo}DeferLocalRpc";
            var verifyMethodName = $"VerifySentTo{defaultSendTo}";
            var senderObject = GetPlayerObject(objectOwner, sender);
@@ -1636,17 +1847,20 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests

            VerifyNotReceived(NetworkManager.ServerClientId, s_ClientIds);

-            for (var i = 0; i < 10; ++i)
+            var clientListExpected = 1;
+            var serverListExpected = 2;
+            for (var i = 1; i <= 10; ++i)
            {
                WaitForMessageReceivedWithTimeTravel<RpcMessage>(clientList);
-                VerifyRemoteReceived(NetworkManager.ServerClientId, NetworkManager.ServerClientId, nameof(UniversalRpcNetworkBehaviour.MutualRecursionClientRpc), clientIdArray, false, false);
+                VerifyRemoteReceived(NetworkManager.ServerClientId, NetworkManager.ServerClientId, nameof(UniversalRpcNetworkBehaviour.MutualRecursionClientRpc), clientIdArray, false, false, clientListExpected);
                VerifyNotReceived(NetworkManager.ServerClientId, serverIdArray);
+                clientListExpected *= 2;

                Clear();
-
                WaitForMessageReceivedWithTimeTravel<RpcMessage>(serverList);
-                VerifyRemoteReceived(NetworkManager.ServerClientId, NetworkManager.ServerClientId, nameof(UniversalRpcNetworkBehaviour.MutualRecursionServerRpc), serverIdArray, false, false);
+                VerifyRemoteReceived(NetworkManager.ServerClientId, NetworkManager.ServerClientId, nameof(UniversalRpcNetworkBehaviour.MutualRecursionServerRpc), serverIdArray, false, false, serverListExpected);
                VerifyNotReceived(NetworkManager.ServerClientId, clientIdArray);
+                serverListExpected *= 2;

                Clear();
            }
@@ -1915,3 +2129,4 @@ namespace Unity.Netcode.RuntimeTests.UniversalRpcTests

    }
 }
+#endif