“Dead reckoning is the process of estimating one’s current position based upon a previously determined position and advancing that position based upon known or estimated speeds over elapsed time, and course.” (Wikipedia)
I’m currently implementing a simple server that makes use of dead reckoning optimization, which minimizes the updates required by making logical assumptions on both the clients and the server.
The objects controlled by users can be said to be turning, or not turning. This presents an issue with dead reckoning (the way I see it.)
For example, say you have point A in time defined by [position, velocity, turning: left/right/no]. Now you want point B after t amount of time. When not turning, the new position is easy to extrapolate. The resulting direction is also easy to extrapolate. But what about when these two factors are combined? The direction of the velocity will be changing along a curve as the object is turning over t amount of time.
Should I perhaps go with another solution (such as making the client send an update for every new direction rather than just telling the server “I’m turning left now”)?
This is in a 2D space, by the way, for the sake of simplicity.
For simplicity let’s say that your vehicles have a turning radius r that’s independant of speed. So to compute the new position given the initial coords and the time:
The last steps needs elaboration.
Given the angle a computed in step 2, if you started at (0,0) with a due north heading (i.e. pi/2 radians) and are turning left then your new positions is: (rcos(a)-1, rsin(a)).
If your original heading was different, say it was “b”, then simply rotate the new position accordingly, i.e. multiply by this rotation matrix:
Finally, add the initial position and you’re done. Now you only need to send an update if you change the velocity or turning direction.