Client wont move with a moving platform, but Host works

Unity Engine
1

So im trying to build a multiplayer game where there is a moving platform, both client and host can activate the moving platform, but only the host moves with the platform, both have the same code
I did some testing and it seem that it has something to do with the fact that I’m using the
“Multiplayer Sample Utilities” that include “Client Network Transform”
which only overrides

using Unity.Netcode.Components;
using UnityEngine;

namespace Unity.Multiplayer.Samples.Utilities.ClientAuthority
{
    /// <summary>
    /// Used for syncing a transform with client side changes. This includes host. Pure server as owner isn't supported by this. Please use NetworkTransform
    /// for transforms that'll always be owned by the server.
    /// </summary>
    [DisallowMultipleComponent]
    public class ClientNetworkTransform : NetworkTransform
    {
        /// <summary>
        /// Used to determine who can write to this transform. Owner client only.
        /// This imposes state to the server. This is putting trust on your clients. Make sure no security-sensitive features use this transform.
        /// </summary>
        protected override bool OnIsServerAuthoritative()
        {
            return false;
        }
    }
}

if I’m using the regular component “Network transform” it works fine but I want a more fluid movement and need the movement be client authoritative

Attaching Also a video for reference
Video : Transfer - Dropbox

2

Yes, because Netcode has Server Authoritative model.
I want to recommend you CodeMonkey tutorial for essential video.

3

Thats exactly the video I was following, and that’s the result, remote client wont move with a moving platform

4

YashalSR,
Could you provide more information about the moving platform?
Is that a server authoritative (i.e. default) NetworkTransform and if so are you using a standard Rigidbody with a NetworkRigidbody? If so, then you are most likely going to need to detect that you are “on the platform” on the client side and adjust the client’s position.
Most likely just creating your own version of the Multiplayer Sample Utilities ClientNetworkTransform and handle applying the platform’s delta offset yourself. It might look something like:

    [DisallowMultipleComponent]
    public class ClientNetworkTransform : NetworkTransform
    {
        private bool m_IsOnPlatform;
        private Transform m_PlatformTransform;
        private Vector3 m_PreviousPlatformPosition;

        public void PlayerOnPlatform(Transform platformTransform)
        {
            if (!IsOwner)
            {
                return;
            }

            m_IsOnPlatform = true;
            m_PlatformTransform = platformTransform;
            m_PreviousPlatformPosition = m_PlatformTransform.position;
        }

        public void PlayerOffPlatform()
        {
            if (!IsOwner)
            {
                return;
            }
            m_IsOnPlatform = false;
        }

        /// <summary>
        /// Used to determine who can write to this transform. Owner client only.
        /// This imposes state to the server. This is putting trust on your clients. Make sure no security-sensitive features use this transform.
        /// </summary>
        protected override bool OnIsServerAuthoritative()
        {
            return false;
        }

        protected override void Update()
        {
            // if the owner is on the platform, then update the client player's position based on the platform's motion
            if (m_IsOnPlatform)
            {
                // Add the delta position of the platform's position to the owner's position
                transform.position += m_PlatformTransform.position - m_PreviousPlatformPosition;
                // Store off the platform's position for next frame delta calculations
                m_PreviousPlatformPosition = m_PlatformTransform.position;
            }
            base.Update();
        }
    }

The above is more “pseudo” code and you might have better ideas on how/where you want to apply the platform’s position delta, but it is the general idea of how you can handle this scenario. If the platform is server authoritative and interpolation is enabled, then the delta position of the platform should be “relatively already smooth”.