I have an authoritative server which is sending position data to client every 100 ms. Ping between client and server is about 70 ms.(which is actually a variable)

I have few questions regarding to interpolation between 2 server states recieved by client.

1-) Where should i place my interpolation code ? Inside my clients update method or should i interpolate whenever i recieve 2 update from server ? 

Example:

 fun onWorldData(data:JSONObject){ // called when update arrives from server.

//initially serverUpdate1 and serverUpdate2 are empty objects.
  serverUpdate1 = serverUpdate2
  serverUpdate2 = data // data is new data which is just arrived from server


if(serverUpdate1.has("x")){ // when at least 2 updates arrived interpolate and set position(just for 1st call)
   

    var blackPieceBodyX = Interpolation.linear.apply(serverUpdate1.get("x").toString().toFloat(),serverUpdate2.get("x").toString().toFloat(),0.15f) // how to calculate 3rd parameter ?
    var blackPieceBodyY = Interpolation.linear.apply(serverUpdate1.get("y").toString().toFloat(),serverUpdate2.get("y").toString().toFloat(),0.15f)

    blackPiece.body.setTransform(Vector2(blackPieceBodyX,blackPieceBodyY),0f) // this code sets position of body

}







    }

As you see interpolation code is called when i recieve update from server, not all the time inside update.

2-)How do i calculate 3rd parameter of Interpolation function ? In above code i was just experimenting with arbitrary numbers.Since server sends it every 100ms and ping is around 70,what should be 3rd parameter of interpolate function and how to calculate it ? Since for sure ping will be part of that calculation formula should i ping server to check ping to use in that formula all the time ? Or timestamp each serverupdate sent by server and when recieved get clients time and substract them ? 

3-)Another approach i tried is this:

    fun onWorldData(data:JSONObject){ // called when sv update arrives to client.

serverUpdate = data
timeSinceLastUpdate = 0f



    }

fun update(){

if(serverUpdate.has("x")){ // if server update arrived
var blackPieceBodyX = Interpolation.linear.apply(blackPiece.body.position.x,serverUpdate.get("x").toString().toFloat(),timeSinceLastUpdate/updateTime)  
  var blackPieceBodyY = Interpolation.linear.apply(blackPiece.body.position.y,serverUpdate.get("y").toString().toFloat(),timeSinceLastUpdate/updateTime) 
  
  blackPiece.body.setTransform(Vector2(blackPieceBodyX,blackPieceBodyY),0f) //set position of body to interpolated values.

timeSinceLastUpdate += deltaTime

}
}

As you see in this example i interpolate between interpolated position of body and serverUpdate, not exactly interpolating between 2 server states inside my update method.updateTime is ping+serverUpdateRate since ping is around 70 and server sends updates every 100 ms it should be like 170(?) or this approach is completely wrong i am not sure.

Right now i am not sending timeStamp with serverUpdate from server but if it is necessary for interpolation 3rd parameter calculation i can do that.

Thanks

It all depends on what you are trying to do.

One possible purpose is to smoothly shift items from their last known position to a "true" position from the server. In that case you set the position it is at now, the position you want to go, and interpolate every frame to smoothly update it.

For more complex code, network clients use timestamps because they live at a different time than the server. In that case the client can do corrections based on the times.  For example, the network packet says the timestamp was accurate 70ms in the past. So it looks up where it thought the client was 70ms in the past, and sees that locally it thought it was somewhere else.  So the client computes the difference from where it thought it was 70ms ago and where the server says it was 70ms ago, then looks at where it thinks it is now relative to where it thought it was 70ms ago.  Now it knows (A) how far apart it was from the server 70ms ago, and (B) how far apart it is from itself 70ms ago. The code can then apply A to B to compute where the corrected location should be right now.  SInce you don't want to pop. you can apply that transion of (A+B) across several frames with an interpolation. 

The second one is more work, but can provide a better game experience, and it is also built in to several engines and networking libraries.

You might be trying to do something else, which is also fine.  Interpolation is just looking at to values --- where it used to be and where it is going --- and then over time shifting it between the two.

I guess i already know what u wrote in your answer but this is not enough for me to implement it with code. Internet is full of those kind of answers i need more spesific one.I am just applying force to a body and returning positions to client and trying to smooth movement.thats all.

What if i just apply force on server and just return positions to client and set them without running physics simulation on client, is it not possible to achieve a smooth movement using interpolation between 2 server states ?

Remember that the client always seems to live in the past due to lag.

If the server is doing ALL aspects of the physics simulation, and the client is running as a view-only display of the physics, this can be visually pleasing although it suffers from lag. The client receives all the position information and physics information, accepts it as authoritative, and runs it until it gets the next update and repeats.

In that scenario the client can run its own physics updates to provide a visually smooth result, but because game physics are almost never deterministic it will quickly drift out of sync with the server. Exactly how smooth it looks depends on latency and bandwidth.

If the client needs to interact with the physics then the client will always be lagged behind the server.

what is pruneSnapshotHistory(now - to_seconds(1)); function is doing ?

System like the one described operate with a sliding window. They track all the changes within a time window, getting bigger and bigger as time passes. When the other side reports that they have the data, old values in the time window can be discarded. In that code, the time window is reduced to one second by pruning old values older than now minus one second.

As an example of that with updates, let's say there is a snapshot A, so it tracks {A} in the history. Now there is another update B, so the history contains {A, B}. Now there is another update C, then another D, so the history contains {A, B, C, D}. When state is received from the server, there is a call to clearHistoryAfterTime(). Let's say that time is the same as B, so item B and everything before it is removed, leaving the window with items {C, D}. Then snap shot E is added, giving {C, D, E}. Over time the number of items in the window slowly slides. Maybe {C, D, E, F}, then { C, D, E, F, G}, then {F, G}, then {F, G, H}, then {F, G, H, I}, and so on.

This is useful for many things. In networking it allows the system to retransmit old data if there was a network glitch. To help with lag, it allows you to rewind to a previous state so you can redo the simulation and replay it with missing data. It can be used to help identify cheaters, and for many other purposes.

and what does 0.0167 mean ?

That's about one graphics frame at 60 Hz. 1 second / 60 is about 0.0166...67 milliseconds.

what is simulateStateByTime(midState, 0.0167); function doing ?

It is simulating one graphics frame.

That will advance the simulation by a single step. The loop runs by advancing one graphics frame at a time until it has caught up by testing (oldTime >= now).

Your second approach is closer to the way it needs to be. Interpolation is just "find me a value somewhere between A and B". So it only works when you have 2 positions to interpolation between. You guess that it "is also wrong" but you've not said why you think it's wrong or what you're observing.

The main bug I can see is not the interpolation but your timekeeping - you're attempting to interpolate with a fixed time value (dt*1000) but that doesn't reflect the passage of time, so the interpolated values won't change either. You need to care about how long has elapsed since you last received something from the server, which implies you need to keep adding to timeSinceLastUpdate each time you update.

Other recommendations:

• For performance and clarity, I strongly suggest you do all that toString/float stuff just once, when you receive the data. Extract the values, store the relevant Vector2. Then, your update system only ever has to deal with the numbers/vectors.)
• I suggest you use a floating point value for time, and measure it in seconds. Trying to measure in milliseconds with integers is not worth the trouble.
• Once you get the basic interpolation working, consider the fact that you won't always receive messages exactly 100ms apart. A simple way to start compensating for this is for the server to include a timestamp in the updates, and instead of applying the received one immediately on the client, you can buffer them up and use them slightly later. This adds a bit more latency but smooths the movement even further and avoids extrapolation errors if a message arrives a bit late.