feat: client networkrigidbody

com.unity.netcode.gameobjects/Components/NetworkRigidbody.cs

@@ -11,6 +11,7 @@ namespace Unity.Netcode.Components
     public class NetworkRigidbody : NetworkBehaviour
     {
         private Rigidbody m_Rigidbody;
+        private NetworkTransform m_NetworkTransform;
 
         private bool m_OriginalKinematic;
 
@@ -20,25 +21,25 @@ public class NetworkRigidbody : NetworkBehaviour
         /// <summary>
         /// Gets a bool value indicating whether this <see cref="NetworkRigidbody"/> on this peer currently holds authority.
         /// </summary>
-        internal bool HasAuthority => NetworkManager.IsServer; // TODO update this once we support owner authoritative NetworkTransform.
+        private bool HasAuthority => m_NetworkTransform.CanCommitToTransform;
 
         private void Awake()
         {
             m_Rigidbody = GetComponent<Rigidbody>();
+            m_NetworkTransform = GetComponent<NetworkTransform>();
         }
 
-        // Currently commented out because it is not needed as authority currently can't change at runtime.
-        // private void FixedUpdate()
-        // {
-        //     if (NetworkManager.IsListening)
-        //     {
-        //         if (HasAuthority != m_IsAuthority)
-        //         {
-        //             m_IsAuthority = HasAuthority;
-        //             UpdateRigidbodyKinematicMode();
-        //         }
-        //     }
-        // }
+        private void FixedUpdate()
+        {
+            if (NetworkManager.IsListening)
+            {
+                if (HasAuthority != m_IsAuthority)
+                {
+                    m_IsAuthority = HasAuthority;
+                    UpdateRigidbodyKinematicMode();
+                }
+            }
+        }
 
         // Puts the rigidbody in a kinematic non-interpolated mode on everyone but the server.
         private void UpdateRigidbodyKinematicMode()

com.unity.netcode.gameobjects/Components/NetworkRigidbody2D.cs

@@ -11,6 +11,7 @@ namespace Unity.Netcode.Components
     public class NetworkRigidbody2D : NetworkBehaviour
     {
         private Rigidbody2D m_Rigidbody;
+        private NetworkTransform m_NetworkTransform;
 
         private bool m_OriginalKinematic;
 
@@ -20,25 +21,25 @@ public class NetworkRigidbody2D : NetworkBehaviour
         /// <summary>
         /// Gets a bool value indicating whether this <see cref="NetworkRigidbody2D"/> on this peer currently holds authority.
         /// </summary>
-        internal bool HasAuthority => NetworkManager.IsServer; // TODO update this once we support owner authoritative NetworkTransform.
+        private bool HasAuthority => m_NetworkTransform.CanCommitToTransform;
 
         private void Awake()
         {
             m_Rigidbody = GetComponent<Rigidbody2D>();
+            m_NetworkTransform = GetComponent<NetworkTransform>();
         }
 
-        // Currently commented out because it is not needed as authority currently can't change at runtime.
-        // private void FixedUpdate()
-        // {
-        //     if (NetworkManager.IsListening)
-        //     {
-        //         if (HasAuthority != m_IsAuthority)
-        //         {
-        //             m_IsAuthority = HasAuthority;
-        //             UpdateRigidbodyKinematicMode();
-        //         }
-        //     }
-        // }
+        private void FixedUpdate()
+        {
+            if (NetworkManager.IsListening)
+            {
+                if (HasAuthority != m_IsAuthority)
+                {
+                    m_IsAuthority = HasAuthority;
+                    UpdateRigidbodyKinematicMode();
+                }
+            }
+        }
 
         // Puts the rigidbody in a kinematic non-interpolated mode on everyone but the server.
         private void UpdateRigidbodyKinematicMode()

com.unity.netcode.gameobjects/Tests/Runtime/Physics/NetworkRigidbody2DTest.cs

@@ -6,12 +6,12 @@
 
 namespace Unity.Netcode.RuntimeTests.Physics
 {
-    public class NetworkRigidbody2DDynamicTest : NetworkRigidbodyTestBase
+    public class NetworkRigidbody2DDynamicTest : NetworkRigidbody2DTestBase
     {
         public override bool Kinematic => false;
     }
 
-    public class NetworkRigidbody2DKinematicTest : NetworkRigidbodyTestBase
+    public class NetworkRigidbody2DKinematicTest : NetworkRigidbody2DTestBase
     {
         public override bool Kinematic => true;
     }
@@ -29,7 +29,7 @@ public override IEnumerator Setup()
             {
                 playerPrefab.AddComponent<NetworkTransform>();
                 playerPrefab.AddComponent<Rigidbody2D>();
-                playerPrefab.AddComponent<NetworkRigidbody>();
+                playerPrefab.AddComponent<NetworkRigidbody2D>();
                 playerPrefab.GetComponent<Rigidbody2D>().isKinematic = Kinematic;
             });
         }
@@ -54,8 +54,7 @@ public IEnumerator TestRigidbodyKinematicEnableDisable()
             Assert.IsNotNull(serverPlayer);
             Assert.IsNotNull(clientPlayer);
 
-            int waitFor = Time.frameCount + 2;
-            yield return new WaitUntil(() => Time.frameCount >= waitFor);
+            yield return NetworkRigidbodyTestBase.WaitForFrames(5);
 
             // server rigidbody has authority and should have a kinematic mode of false
             Assert.True(serverPlayer.GetComponent<Rigidbody2D>().isKinematic == Kinematic);
@@ -66,12 +65,14 @@ public IEnumerator TestRigidbodyKinematicEnableDisable()
             // despawn the server player, (but keep it around on the server)
             serverPlayer.GetComponent<NetworkObject>().Despawn(false);
 
-            yield return null;
+            yield return NetworkRigidbodyTestBase.WaitForFrames(5);
 
             Assert.IsTrue(serverPlayer.GetComponent<Rigidbody2D>().isKinematic == Kinematic);
 
-            yield return null;
+            yield return NetworkRigidbodyTestBase.WaitForFrames(5);
+
             Assert.IsTrue(clientPlayer == null); // safety check that object is actually despawned.
         }
+
     }
 }

com.unity.netcode.gameobjects/Tests/Runtime/Physics/NetworkRigidbodyTest.cs

@@ -54,8 +54,7 @@ public IEnumerator TestRigidbodyKinematicEnableDisable()
             Assert.IsNotNull(serverPlayer);
             Assert.IsNotNull(clientPlayer);
 
-            int waitFor = Time.frameCount + 2;
-            yield return new WaitUntil(() => Time.frameCount >= waitFor);
+            yield return WaitForFrames(5);
 
             // server rigidbody has authority and should have a kinematic mode of false
             Assert.True(serverPlayer.GetComponent<Rigidbody>().isKinematic == Kinematic);
@@ -66,12 +65,19 @@ public IEnumerator TestRigidbodyKinematicEnableDisable()
             // despawn the server player (but keep it around on the server)
             serverPlayer.GetComponent<NetworkObject>().Despawn(false);
 
-            yield return null;
+            yield return WaitForFrames(5);
 
             Assert.IsTrue(serverPlayer.GetComponent<Rigidbody>().isKinematic == Kinematic);
 
-            yield return null;
+            yield return WaitForFrames(5);
+
             Assert.IsTrue(clientPlayer == null); // safety check that object is actually despawned.
         }
+
+        public static IEnumerator WaitForFrames(int count)
+        {
+            int nextFrameNumber = Time.frameCount + count;
+            yield return new WaitUntil(() => Time.frameCount >= nextFrameNumber);
+        }
     }
 }

testproject/Assets/Tests/Runtime/Physics/NetworkRigidbody2DCntChangeOwnershipTest.cs

@@ -0,0 +1,95 @@
+// using System.Collections;
+// using NUnit.Framework;
+// using Unity.Netcode.Components;
+// using Unity.Netcode.Samples;
+// using UnityEngine;
+// using UnityEngine.TestTools;
+//
+// // Tests for ClientNetworkTransform (CNT) + NetworkRigidbody. This test is in TestProject because it needs access to ClientNetworkTransform
+// namespace Unity.Netcode.RuntimeTests.Physics
+// {
+//     public class NetworkRigidbody2DDynamicCntChangeOwnershipTest : NetworkRigidbody2DCntChangeOwnershipTestBase
+//     {
+//         public override bool Kinematic => false;
+//     }
+//
+//     public class NetworkRigidbody2DKinematicCntChangeOwnershipTest : NetworkRigidbody2DCntChangeOwnershipTestBase
+//     {
+//         public override bool Kinematic => true;
+//     }
+//
+//     public abstract class NetworkRigidbody2DCntChangeOwnershipTestBase : BaseMultiInstanceTest
+//     {
+//         protected override int NbClients => 1;
+//
+//         public abstract bool Kinematic { get; }
+//
+//         [UnitySetUp]
+//         public override IEnumerator Setup()
+//         {
+//             yield return StartSomeClientsAndServerWithPlayers(true, NbClients, playerPrefab =>
+//             {
+//                 playerPrefab.AddComponent<ClientNetworkTransform>();
+//                 playerPrefab.AddComponent<Rigidbody2D>();
+//                 playerPrefab.AddComponent<NetworkRigidbody2D>();
+//                 playerPrefab.GetComponent<Rigidbody2D>().isKinematic = Kinematic;
+//             });
+//         }
+//         /// <summary>
+//         /// Tests that a server can destroy a NetworkObject and that it gets despawned correctly.
+//         /// </summary>
+//         /// <returns></returns>
+//         [UnityTest]
+//         public IEnumerator TestRigidbodyKinematicEnableDisable()
+//         {
+//             // This is the *SERVER VERSION* of the *CLIENT PLAYER*
+//             var serverClientPlayerResult = new MultiInstanceHelpers.CoroutineResultWrapper<NetworkObject>();
+//             yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.GetNetworkObjectByRepresentation((x => x.IsPlayerObject && x.OwnerClientId == m_ClientNetworkManagers[0].LocalClientId), m_ServerNetworkManager, serverClientPlayerResult));
+//             var serverPlayer = serverClientPlayerResult.Result.gameObject;
+//
+//             // This is the *CLIENT VERSION* of the *CLIENT PLAYER*
+//             var clientClientPlayerResult = new MultiInstanceHelpers.CoroutineResultWrapper<NetworkObject>();
+//             yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.GetNetworkObjectByRepresentation((x => x.IsPlayerObject && x.OwnerClientId == m_ClientNetworkManagers[0].LocalClientId), m_ClientNetworkManagers[0], clientClientPlayerResult));
+//             var clientPlayer = clientClientPlayerResult.Result.gameObject;
+//
+//             Assert.IsNotNull(serverPlayer);
+//             Assert.IsNotNull(clientPlayer);
+//
+//             int waitFor = Time.frameCount + 2;
+//             yield return new WaitUntil(() => Time.frameCount >= waitFor);
+//
+//             TestKinematicSetCorrectly(clientPlayer, serverPlayer);
+//
+//
+//             // give server ownership over the player
+//
+//             serverPlayer.GetComponent<NetworkObject>().ChangeOwnership(m_ServerNetworkManager.ServerClientId);
+//
+//             yield return null;
+//             yield return null;
+//
+//             // server should now be able to commit to transform
+//             TestKinematicSetCorrectly(serverPlayer, clientPlayer);
+//
+//             // return ownership to client
+//             serverPlayer.GetComponent<NetworkObject>().ChangeOwnership(m_ClientNetworkManagers[0].LocalClientId);
+//             yield return null;
+//             yield return null;
+//
+//             // client should again be able to commit
+//             TestKinematicSetCorrectly(clientPlayer, serverPlayer);
+//         }
+//
+//
+//
+//         private void TestKinematicSetCorrectly(GameObject canCommitPlayer, GameObject canNotCommitPlayer)
+//         {
+//
+//             // can commit player has authority and should have a kinematic mode of false (or true in case body was already kinematic).
+//             Assert.True(canCommitPlayer.GetComponent<Rigidbody2D>().isKinematic == Kinematic);
+//
+//             // can not commit player has no authority and should have a kinematic mode of true
+//             Assert.True(canNotCommitPlayer.GetComponent<Rigidbody2D>().isKinematic);
+//         }
+//     }
+// }

testproject/Assets/Tests/Runtime/Physics/NetworkRigidbody2DCntTest.cs

@@ -0,0 +1,82 @@
+// using System.Collections;
+// using NUnit.Framework;
+// using Unity.Netcode.Components;
+// using Unity.Netcode.Samples;
+// using UnityEngine;
+// using UnityEngine.TestTools;
+//
+// // Tests for ClientNetworkTransform (CNT) + NetworkRigidbody2D. This test is in TestProject because it needs access to ClientNetworkTransform
+// namespace Unity.Netcode.RuntimeTests.Physics
+// {
+//     public class NetworkRigidbody2DDynamicCntTest : NetworkRigidbody2DCntTestBase
+//     {
+//         public override bool Kinematic => false;
+//     }
+//
+//     public class NetworkRigidbody2DKinematicCntTest : NetworkRigidbody2DCntTestBase
+//     {
+//         public override bool Kinematic => true;
+//     }
+//
+//     public abstract class NetworkRigidbody2DCntTestBase : BaseMultiInstanceTest
+//     {
+//         protected override int NbClients => 1;
+//
+//         public abstract bool Kinematic { get; }
+//
+//         [UnitySetUp]
+//         public override IEnumerator Setup()
+//         {
+//             yield return StartSomeClientsAndServerWithPlayers(true, NbClients, playerPrefab =>
+//             {
+//                 playerPrefab.AddComponent<ClientNetworkTransform>();
+//                 playerPrefab.AddComponent<Rigidbody2D>();
+//                 playerPrefab.AddComponent<NetworkRigidbody2D>();
+//                 playerPrefab.GetComponent<Rigidbody2D>().isKinematic = Kinematic;
+//             });
+//         }
+//
+//         /// <summary>
+//         /// Tests that a server can destroy a NetworkObject and that it gets despawned correctly.
+//         /// </summary>
+//         /// <returns></returns>
+//         [UnityTest]
+//         public IEnumerator TestRigidbodyKinematicEnableDisable()
+//         {
+//             // This is the *SERVER VERSION* of the *CLIENT PLAYER*
+//             var serverClientPlayerResult = new MultiInstanceHelpers.CoroutineResultWrapper<NetworkObject>();
+//             yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.GetNetworkObjectByRepresentation((x => x.IsPlayerObject && x.OwnerClientId == m_ClientNetworkManagers[0].LocalClientId), m_ServerNetworkManager, serverClientPlayerResult));
+//             var serverPlayer = serverClientPlayerResult.Result.gameObject;
+//
+//             // This is the *CLIENT VERSION* of the *CLIENT PLAYER*
+//             var clientClientPlayerResult = new MultiInstanceHelpers.CoroutineResultWrapper<NetworkObject>();
+//             yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.GetNetworkObjectByRepresentation((x => x.IsPlayerObject && x.OwnerClientId == m_ClientNetworkManagers[0].LocalClientId), m_ClientNetworkManagers[0], clientClientPlayerResult));
+//             var clientPlayer = clientClientPlayerResult.Result.gameObject;
+//
+//             Assert.IsNotNull(serverPlayer);
+//             Assert.IsNotNull(clientPlayer);
+//
+//             int waitFor = Time.frameCount + 2;
+//             yield return new WaitUntil(() => Time.frameCount >= waitFor);
+//
+//             TestKinematicSetCorrectly(clientPlayer, serverPlayer);
+//
+//             // despawn the server player
+//             serverPlayer.GetComponent<NetworkObject>().Despawn(false);
+//
+//             yield return null;
+//             yield return null;
+//             Assert.IsTrue(clientPlayer == null); // safety check that object is actually despawned.
+//         }
+//
+//         private void TestKinematicSetCorrectly(GameObject canCommitPlayer, GameObject canNotCommitPlayer)
+//         {
+//
+//             // can commit player has authority and should have a kinematic mode of false (or true in case body was already kinematic).
+//             Assert.True(canCommitPlayer.GetComponent<Rigidbody2D>().isKinematic == Kinematic);
+//
+//             // can not commit player has no authority and should have a kinematic mode of true
+//             Assert.True(canNotCommitPlayer.GetComponent<Rigidbody2D>().isKinematic);
+//         }
+//     }
+// }