Hey!

I have a new player position coming every 50ms. This helped me achieve the smoothest interpolation:

newPos.x = MathUtils.lerp(getPosX(), interpolateToX, delta * 6f);
newPos.y = MathUtils.lerp(getPosY(), interpolateToY, delta * 6f);

However, this one feels too floaty and unrealistic. Especially, when character jumps, he slows down the closer he gets to the ground. I understand why this is happening. How could I interpolate smoothly but still realistically? Maybe somehow make time parameter dependant on distance?

Depending on the situation, you maybe could get away with simulating gravity and only interpolating the horizontal movement. I have no idea if this is true, but Guild wars 2 feels like it does this for proxy player characters (with occasional corrections).

It seems to me that you are currently overwriting the position in each interpolation step. How about saving the old and target position and calculate the current position by interpolating between those two.

So instead of

position = lerp(position, targetPosition, delta)

do

position = lerp(oldPosition, targetPosition, t)

Where t is a counter that is reset on every position update and that is increased according to elapsed time (make sure that it is clamped to [0,1]).

When a new position update arrives, it will become the new target position and the previous targetPosition will become the oldPosition.

Yeah, you need to keep a short history of the control points (position, orientation, but also timestamps). Two points are enough for linear interpolation. The character position / orientation is basically an interpolation / extrapolation of the path defined by the control points, and the current time on the character update.

To keep it simple, you can just do linear interpolation / extrapolation. Then you can expand to other more interesting algorithms.

The character position / orientation is basically an interpolation / extrapolation of the path defined by the control points, and the current time on the character update.

https://developer.valvesoftware.com/wiki/Source_Multiplayer_Networking

https://code.google.com/archive/p/nuclear-bomberman/wikis/Interpolation.wiki

After reading these 2 articles, I was able to implement mine.

- when receiving update, calculate where the entity would be 100 ms from now, based on position/velocity
- now, subtract the current entity position from the projected entity position -- this is the movement vector for the next 100 ms
- divide by 100 ms to get the speed of movement

// generic rigid body physics.
// simple linear / velocity vectors.
struct PhysicalBody
{
    Vector position;    // 3D position.
    Vector velocity;    // 3D velocity vector.
};

// a network update. Contains 
// the remote state of the physical body,
// as well as the time it was sent from. 
struct ControlPoint
{
    PhysicalBody body;  // body position and velocity.
    float t;            // time from when the body position was sent.
};

// calculate body position, extrapolating from a control point.
PhysicalBody extrapolate(ControlPoint cp, float t)
{
    PhysicalBody body;

    float dt = (t - cp.t);                          // extrapolation time.
    body.position = cp.position + cp.velocity * dt; // extrapolate (predict) using the body velocity.
    
    return body;
}

// interpolate between two bodies.
PhysicalBody interpolate(PhysicalBody a, PhysicalBody b, float u)
{
    PhysicalBody c;

    c.position = a.position + (b.position - a.position) * u; // simple linear interpolation.
    c.velocity = a.velocity + (b.velocity - a.velocity) * u; // simple linear interpolation.
    
    return c;
}


ControlPoint cp[2];         // the control points we used to extrapolate the remote player position.
float network_dt = 0.1f;    // network update period (100ms, or whatever your send rate is).
float snap_speed = 0.9f;    // how fast we snap to the new extrapolation. something sensible between [0.5f, 1.5f].
PhysicalBody player;        // the predicted remote player position.
float time;                 // the current time. 

// it's time to update the player position
// using two control points that we will extrapolate from.
void extrapolate_player()
{
    // extrapolate from the two control points.
    PhysicalBody a = extrapolate(cp[0], time);              // extrapolate to current time using the oldest control point.
    PhysicalBody b = extrapolate(cp[1], time);              // extrapolate to current time using the latest control point.

    // blend the two positions together. 
    // Once we're about ready to receive a new update 
    // (depending on snap_speed), we will be following 
    // the most up-to-date extrapolation.
    float blend_dt = network_dt * snap_speed;               // the network update rate, assuming it's constant. Add +/-10% in extra.
    float u = m_blend_timer.get_elapsed_time() / blend_dt;  // the blend factor between the two extrapolations.
    u = clamp(u, 0.0f, 1.0f);                               // clamp u in range [0.0f, 1.0f].
    
    // the new player position, 
    // blended between two extrapolations.
    player = interpolate(a, b, u);
}

// we received our first network update. 
// we can calculate extrapolations from here.
void receive_first_network_update(ControlPoint new_cp)
{
    // set both control points to the same value.
    cp[0] = new_cp;
    cp[1] = new_cp;

    // restart the blending.
    m_blend_timer.start();

    // use arbitrary value.
    network_dt = 0.1;
}

// network sent us a new update.
// update exrapolation cache.
void receive_new_network_update(ControlPoint new_cp)
{
    // measure the network update rate. 
    // although if the update rate is constant, network_dt could just be left alone.
    network_dt = (new_cp.t - cp[1].t); 

    // use the current body position and time 
    // as the oldest extrapolation path.
    cp[0].body = player;
    cp[0].t = time;

    // use the new control point as the latest extrpolation path.
    cp[1] = new_cp;

    // restart the blending.
    m_blend_timer.start();
}