Hey all, I need some help solidifying my understanding of peer replication.

In a networked game setup where the player is ahead in time and peers are behind, I learned that the process for replicating peers is:

1. The server sends you their state (position, velocity, facing, and inputs).
2. Wait until you have at least 2 states for that peer.
3. Lerp between the latest 2 states for that peer.
4. If you run out of data, keep predicting with their latest inputs. When their data finally comes through, jump them back to the oldest authoritative point and process multiple states until they're caught up.

I'm wondering about steps 2 and 3 though, why not look at 1 state at a time and use your prediction code? If you need to put in the prediction/replay code for #4 anyway, it seems like you would just use that. Something like:

1. The server sends you their state (position, velocity, facing, and inputs).
2. Jump them to that state, or verify that your last prediction was correct.
3. Sim them to their next predicted state (deterministic sim, should be perfect).
4. If you run out of data, keep predicting with their latest inputs. When their data finally comes through, jump them back to the oldest authoritative point and process multiple states until they're caught up.

You would add some buffer time to try and make sure you can always base your prediction off real data.

Is there something I'm missing that makes the first approach better? It could be that wherever I learned this approach from was just being unclear about the difference between the sim update and the render update (where you are constantly lerping between 2 knowns), so it'll be good to get my understanding straightened out.

hplus0603 said:

This is exactly the “interpolation” versus “extrapolation” question.

Which is more important? Having remote entities be “somewhat close to right, in current time,” or having remote entities be “following the correct path, in past time?”

The choice between these two options depends on your specific gameplay requirements. The Entity Position Interpolation Code illustration/library lets you play with this trade-off: https://www.mindcontrol.org/~hplus/epic/

That makes sense to me in the case of “we only interpolate between known data and never extrapolate” vs “we start extrapolating as soon as we get a starting state”, but both of the cases I've listed seem to be a little of both.

In both cases, you wait until you've buffered a couple ticks worth of state. In the first, you then interpolate until you run out of data, then you extrapolate. In the second, you “extrapolate” until you run out of data, then actually extrapolate. By “extrapolate”, I mean that you're always using known data and a deterministic sim, so isn't it as correct as the interpolation?

I guess I'm asking about actual interpolation vs using extrapolation code with authoritative data. I don't see why you would do an actual lerp when you can reuse the prediction code for the same effect?