Unity-Technologies · SamuelBellomo · Jun 30, 2021 · May 21, 2021 · May 21, 2021 · May 21, 2021
@@ -89,6 +89,7 @@ public enum Authority
         /// <summary>
         /// Sets whether this transform should sync local or world properties. This is important to set since reparenting this transform
         /// could have issues if using world position (depending on who gets synced first: the parent or the child)
+        /// Having a child always at position 0,0,0 for example will have less possibilities of desync than when using world positions
         /// </summary>
         [SerializeField, Tooltip("Sets whether this transform should sync local or world properties. This should be set if reparenting.")]
         private NetworkVariableBool m_UseLocal = new NetworkVariableBool();
@@ -99,10 +100,46 @@ public bool UseLocal
             set => m_UseLocal.Value = value;
         }
 
+        /// <summary>
+        /// Updates the NetworkTransform's authority model at runtime.
+        /// </summary>
+        /// <param name="newAuthority"></param>
+        public void SetAuthority(Authority newAuthority)
+        {
+            TransformAuthority = newAuthority;
+            UpdateVarPermissions();
+            // todo this should be synced with the other side. let's wait for a more final solution before adding more code here
+        }
+
+        private void UpdateOneVarPermission<T>(NetworkVariable<T> varToUpdate)
+        {
+            switch (TransformAuthority)
+            {
+                case Authority.Client:
+                    varToUpdate.Settings.WritePermission = NetworkVariablePermission.OwnerOnly;
+                    break;
+                case Authority.Shared:
+                    varToUpdate.Settings.WritePermission = NetworkVariablePermission.Everyone;
+                    break;
+                case Authority.Server:
+                    m_NetworkPosition.Settings.WritePermission = NetworkVariablePermission.ServerOnly;
+                    break;
+                default:
+                    throw new NotImplementedException($"{TransformAuthority} is not handled");
+            }
+        }
+
+        private void UpdateVarPermissions()
+        {
+            UpdateOneVarPermission(m_NetworkPosition);
+            UpdateOneVarPermission(m_NetworkRotation);
+            UpdateOneVarPermission(m_NetworkWorldScale);
+            UpdateOneVarPermission(m_UseLocal);
+        }
+
         private NetworkVariableVector3 m_NetworkPosition = new NetworkVariableVector3();
         private NetworkVariableQuaternion m_NetworkRotation = new NetworkVariableQuaternion();
         private NetworkVariableVector3 m_NetworkWorldScale = new NetworkVariableVector3();
-        // private NetworkTransform m_NetworkParent; // TODO handle this here?
 
         private Transform m_Transform;
 
@@ -197,20 +234,7 @@ void SetupVar<T>(NetworkVariable<T> v, T initialValue, ref T oldVal)
             SetupVar(m_NetworkRotation, m_CurrentRotation, ref m_OldRotation);
             SetupVar(m_NetworkWorldScale, m_CurrentScale, ref m_OldScale);
 
-            if (TransformAuthority == Authority.Client)
-            {
-                m_NetworkPosition.Settings.WritePermission = NetworkVariablePermission.OwnerOnly;
-                m_NetworkRotation.Settings.WritePermission = NetworkVariablePermission.OwnerOnly;
-                m_NetworkWorldScale.Settings.WritePermission = NetworkVariablePermission.OwnerOnly;
-                m_UseLocal.Settings.WritePermission = NetworkVariablePermission.OwnerOnly;
-            }
-            else if (TransformAuthority == Authority.Shared)
-            {
-                m_NetworkPosition.Settings.WritePermission = NetworkVariablePermission.Everyone;
-                m_NetworkRotation.Settings.WritePermission = NetworkVariablePermission.Everyone;
-                m_NetworkWorldScale.Settings.WritePermission = NetworkVariablePermission.Everyone;
-                m_UseLocal.Settings.WritePermission = NetworkVariablePermission.Everyone;
-            }
+            UpdateVarPermissions();
         }
 
         public override void OnNetworkObjectParentChanged(NetworkObject parentNetworkObject)

@@ -127,7 +127,7 @@ public NetworkPrefabHandler PrefabHandler
         public ulong ServerClientId => NetworkConfig.NetworkTransport?.ServerClientId ?? throw new NullReferenceException($"The transport in the active {nameof(NetworkConfig)} is null");
 
         /// <summary>
-        /// The clientId the server calls the local client by, only valid for clients
+        /// Returns ServerClientId if IsServer or LocalClientId if not
         /// </summary>
         public ulong LocalClientId
         {

@@ -178,7 +178,7 @@ private class CoroutineRunner : MonoBehaviour
         private static CoroutineRunner s_CoroutineRunner;
 
         /// <summary>
-        /// Runs a IEnumerator as a Coroutine on a dummy GameObject.
+        /// Runs a IEnumerator as a Coroutine on a dummy GameObject. Used to get exceptions coming from the coroutine
         /// </summary>
         /// <param name="enumerator">The IEnumerator to run</param>
         public static Coroutine Run(IEnumerator enumerator)

@@ -0,0 +1,151 @@
+using System;
+using System.Collections;
+using System.Text.RegularExpressions;
+using MLAPI.Prototyping;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+using static MLAPI.Prototyping.NetworkTransform;
+
+namespace MLAPI.RuntimeTests
+{
+    [TestFixture(true)]
+    [TestFixture(false)]
+    public class NetworkTransformTests : BaseMultiInstanceTest
+    {
+        private NetworkObject m_ClientSideClientPlayer;
+        private NetworkObject m_ServerSideClientPlayer;
+
+        private bool m_TestWithHost;
+
+        public NetworkTransformTests(bool testWithHost)
+        {
+            m_TestWithHost = testWithHost; // from test fixture
+        }
+
+        protected override int NbClients => 1;
+
+        [UnitySetUp]
+        public override IEnumerator Setup()
+        {
+            yield return StartSomeClientsAndServerWithPlayers(useHost: m_TestWithHost, nbClients: NbClients, updatePlayerPrefab: playerPrefab =>
+            {
+                var networkTransform = playerPrefab.AddComponent<NetworkTransform>();
+            });
+
+            // 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));
+
+            // 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));
+
+            m_ServerSideClientPlayer = serverClientPlayerResult.Result;
+            m_ClientSideClientPlayer = clientClientPlayerResult.Result;
+        }
+
+        [UnityTest]
+        [TestCase(true, Authority.Client, ExpectedResult = null)]
+        [TestCase(true, Authority.Server, ExpectedResult = null)]
+        [TestCase(false, Authority.Client, ExpectedResult = null)]
+        [TestCase(false, Authority.Server, ExpectedResult = null)]
+        public IEnumerator TestAuthoritativeTransformChangeOneAtATime(bool testLocalTransform, Authority authorityToTest)
+        {
+            var waitResult = new MultiInstanceHelpers.CoroutineResultWrapper<bool>();
+
+            var networkTransform = (authorityToTest == Authority.Client ? m_ClientSideClientPlayer : m_ServerSideClientPlayer).GetComponent<NetworkTransform>();
+            networkTransform.SetAuthority(authorityToTest);
+
+            var otherSideNetworkTransform = (authorityToTest == Authority.Client ? m_ServerSideClientPlayer : m_ClientSideClientPlayer).GetComponent<NetworkTransform>();
+            otherSideNetworkTransform.SetAuthority(authorityToTest);
+
+            bool HasAuthority(NetworkTransform transform)
+            {
+                return transform.NetworkObject.NetworkManager.IsServer && transform.TransformAuthority == Authority.Server ||
+                    transform.NetworkObject.NetworkManager.IsClient && transform.TransformAuthority == Authority.Client;
+            }
+
+            if (HasAuthority(networkTransform))
+            {
+                networkTransform.UseLocal = testLocalTransform;
+            }
+
+            if (HasAuthority(otherSideNetworkTransform))
+            {
+                otherSideNetworkTransform.UseLocal = testLocalTransform;
+            }
+
+            float approximation = 0.05f;
+
+            // test position
+            var playerTransform = networkTransform.transform;
+            playerTransform.position = new Vector3(10, 20, 30);
+            Assert.AreEqual(Vector3.zero, otherSideNetworkTransform.transform.position, "server side pos should be zero at first"); // sanity check
+            yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.WaitForCondition(() => otherSideNetworkTransform.transform.position.x > approximation, waitResult, maxFrames: 30));
+            if (!waitResult.Result)
+            {
+                throw new Exception("timeout while waiting for position change");
+            }
+            Assert.True(new Vector3(10, 20, 30) == otherSideNetworkTransform.transform.position, $"wrong position on ghost, {otherSideNetworkTransform.transform.position}"); // Vector3 already does float approximation with ==
+
+            // test rotation
+            playerTransform.rotation = Quaternion.Euler(45, 40, 35); // using euler angles instead of quaternions directly to really see issues users might encounter
+            Assert.AreEqual(Quaternion.identity, otherSideNetworkTransform.transform.rotation, "wrong initial value for rotation"); // sanity check
+            yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.WaitForCondition(() => otherSideNetworkTransform.transform.rotation.eulerAngles.x > approximation, waitResult, maxFrames: 30));
+            if (!waitResult.Result)
+            {
+                throw new Exception("timeout while waiting for position change");
+            }
+            // approximation needed here since eulerAngles isn't super precise.
+            Assert.LessOrEqual(Math.Abs(45 - otherSideNetworkTransform.transform.rotation.eulerAngles.x), approximation, $"wrong rotation on ghost on x, got {otherSideNetworkTransform.transform.rotation.eulerAngles.x}");
+            Assert.LessOrEqual(Math.Abs(40 - otherSideNetworkTransform.transform.rotation.eulerAngles.y), approximation, $"wrong rotation on ghost on y, got {otherSideNetworkTransform.transform.rotation.eulerAngles.y}");
+            Assert.LessOrEqual(Math.Abs(35 - otherSideNetworkTransform.transform.rotation.eulerAngles.z), approximation, $"wrong rotation on ghost on z, got {otherSideNetworkTransform.transform.rotation.eulerAngles.z}");
+
+            // test scale
+            UnityEngine.Assertions.Assert.AreApproximatelyEqual(1f, otherSideNetworkTransform.transform.lossyScale.x, "wrong initial value for scale"); // sanity check
+            UnityEngine.Assertions.Assert.AreApproximatelyEqual(1f, otherSideNetworkTransform.transform.lossyScale.y, "wrong initial value for scale"); // sanity check
+            UnityEngine.Assertions.Assert.AreApproximatelyEqual(1f, otherSideNetworkTransform.transform.lossyScale.z, "wrong initial value for scale"); // sanity check
+            playerTransform.localScale = new Vector3(2, 3, 4);
+            yield return MultiInstanceHelpers.Run(MultiInstanceHelpers.WaitForCondition(() => otherSideNetworkTransform.transform.lossyScale.x > 1f + approximation, waitResult, maxFrames: 30));
+            if (!waitResult.Result)
+            {
+                throw new Exception("timeout while waiting for position change");
+            }
+            UnityEngine.Assertions.Assert.AreApproximatelyEqual(2f, otherSideNetworkTransform.transform.lossyScale.x, "wrong scale on ghost");
+            UnityEngine.Assertions.Assert.AreApproximatelyEqual(3f, otherSideNetworkTransform.transform.lossyScale.y, "wrong scale on ghost");
+            UnityEngine.Assertions.Assert.AreApproximatelyEqual(4f, otherSideNetworkTransform.transform.lossyScale.z, "wrong scale on ghost");
+
+            // todo reparent and test
+            // todo test all public API
+        }
+
+        [UnityTest]
+        [TestCase(Authority.Client, ExpectedResult = null)]
+        [TestCase(Authority.Server, ExpectedResult = null)]
+        public IEnumerator TestCantChangeTransformFromOtherSideAuthority(Authority authorityToTest)
+        {
+            // test server can't change client authoritative transform
+            var networkTransform = (authorityToTest == Authority.Client ? m_ClientSideClientPlayer : m_ServerSideClientPlayer).GetComponent<NetworkTransform>();
+            networkTransform.SetAuthority(authorityToTest);
+
+            var otherSideNetworkTransform = (authorityToTest == Authority.Client ? m_ServerSideClientPlayer : m_ClientSideClientPlayer).GetComponent<NetworkTransform>();
+            otherSideNetworkTransform.SetAuthority(authorityToTest);
+
+            Assert.AreEqual(Vector3.zero, otherSideNetworkTransform.transform.position, "other side pos should be zero at first"); // sanity check
+            otherSideNetworkTransform.transform.position = new Vector3(4, 5, 6);
+
+            yield return new WaitForFixedUpdate();
+
+            LogAssert.Expect(LogType.Error, new Regex(".*[Aa]uthority.*"));
+            Assert.AreEqual(Vector3.zero, otherSideNetworkTransform.transform.position, "got authority error, but other side still moved!");
+        }
+
+        [UnityTearDown]
+        public override IEnumerator Teardown()
+        {
+            yield return base.Teardown();
+            UnityEngine.Object.Destroy(m_PlayerPrefab);
+        }
+    }
+}
@@ -2,7 +2,8 @@
     "name": "Unity.Multiplayer.MLAPI.RuntimeTests",
     "references": [
         "Unity.Multiplayer.MLAPI.Runtime",
-        "Unity.Multiplayer.MLAPI.Editor"
+        "Unity.Multiplayer.MLAPI.Editor",
+        "Unity.Multiplayer.MLAPI.Prototyping"
     ],
     "optionalUnityReferences": [
         "TestAssemblies"

@@ -69,3 +69,5 @@ crashlytics-build.properties
 # Temporary auto-generated Android Assets
 /[Aa]ssets/[Ss]treamingAssets/aa.meta
 /[Aa]ssets/[Ss]treamingAssets/aa/*
+
+InitTestScene*