Input lag

Unity Engine
1

Hi. Simple game - 2 players connected by phone, control by joystick prefab
1 phone host+ client
2 phone client.
they flying on scene with rigidbody 2d, try to hit each other. I’m using server RPC call -

public class PlayerController : NetworkBehaviour
{
    [SerializeField] private Joystick _joystick;
    public float x, y;
    [SerializeField] public Rigidbody2D _rigidbody2D;
    [SerializeField] private float XfromServer, YFromServer;

    public float Speed = 5f;
    void Start()
    {
        if (IsLocalPlayer && IsClient)
        {
            Debug.Log("THIS IS LOCAL player!!");
           _joystick = GameObject.FindGameObjectWithTag("GameController").GetComponent<Joystick>();
        }

        if(IsHost)
        {
            Debug.Log("this is host!!");
        }
        if (!IsLocalPlayer)
        {
            _joystick = GameObject.FindGameObjectWithTag("GameController").GetComponent<Joystick>();
            _rigidbody2D = GetComponent<Rigidbody2D>();
        }

    }
    public void Update()
    {
       if (IsLocalPlayer )
        {
            x = _joystick.Horizontal * Speed;
            y = _joystick.Vertical * Speed;

            PlayerControlServerRpc(x, y);
        }
    }

    [ServerRpc]
    private void PlayerControlServerRpc(float x, float y)
    {
        Debug.Log($"Server received X={x} and Y={y}");
        _rigidbody2D.AddForce(new Vector3(x, y, 0));
    }
}

everything seem to work fine and smooth but the client always have “input lag” example
fit joystick right, player fly right, fit joystick left need to wait about 1 sec to fly left.
All tested on different phones, and even on same 1 PC, always same issue, but host is moving of course instantly. How can I speed up clients control?

2

The delay is because of two things: one is the lag due to the distance/network speed between the server and client (which is zero when on the same machine), and the other is due to the time it takes for the Rpc to be sent to the server plus back to the client (through NetworkTransform/NetworkRigidbody I assume). The latter can be sped up by increasing the “Tick Rate” in your NetworkManager, which you can view as the number of communications between server and client per second. If your tick rate is 20 for example, the minimum amount of time between the player providing input and seeing a result (even on the same machine) is 2*1/20=0.1 seconds.

The input lag can be entirely avoided by processing and applying the input on the client directly (using a ClientNetworkTransform instead of a NetworkTransform, and no NetworkRigidbody). There will of course still be a delay for everyone else when a player provides an input, but not for themselves. The downside is that this makes cheating easier, since it means the client’s inputs are fully trusted.

The best but hardest option, which is currently not a part of Netcode but for very simple games could be coded up yourself without too much effort, is to do client-side prediction: apply the input immediately on the client, but then also send it to the server. If the server then finds a mismatch for some reason, the client is corrected. Most AAA fast-paced multiplayer games (e.g. Overwatch) do something like this – but it’s much harder than just using a ClientNetworkTransform and trusting the clients.

1 Like
3

exactly we use much rigidbodies :frowning: yes on “ClientNetworkTransform” it all were good.
Well thx for good advice man! I will try to play with tick rate and maybe write some client - prediction.
Thanks a lot for help!