The answer is the guy drives the lap on his PC and to him everything seems
normal. The server does not tell the client where it thinks the player is on
the track. The client reports it's position to the server and, in return
gets info on where the server thinks the player's opponents are. The client
uses this info for drawing them on screen, or in the mirrors and calculates,
if applicable, collision detection between the local car and the remote
opponent. We see that each client thus calculates it's own version of a
crash (it works both ways, you're the remote on the other guy's machine),
which it corrects with info from the other (and different) crash. This is
the reason why crashes get out of hand on warped connections, but that's
besides the point.
To return to the problem at hand... if your data gets garbled on the way to
the server, you don't notice a thing, but, to the server, your car may
appear to jump forward a fair number of yards (which it thinks nothing of,
it's a computer program)... the server then forwards this position change to
your opponents, who scratch their heads at how you managed to magically
"warp" past them. To the client's machine you never traveled the stretch of
road it's local car occupies so there's no crash. One moment you're behind,
the next ahead, simple as that. Again, it is a program, it does not
interpret the data it gets, it just reads the position (and attitude info)
on the opponent from a buffer somewhere, models, scales and shades the
representation of the car and displays it at the appropriate position on
screen. To the client, there's nothing weird about a car being in one spot
in one frame and in another in the next. The car exhibits this behavior
EVERY frame. It's just us who interpret the distance "traveled" as being
impossible.
IMO there's three ways for such an anomaly to occur. Data may be lost, data
may be received in the wrong order or a combination of both.
A typical example of lost data is the "jump pass". I am racing you at The
Glen and I'm faster, but a lot of my data gets lost. I close up to you in
the Outer Loop and get the power down nice and early. At this point the host
loses track of me... your client, because it's important to you to be able
to see/hear where I am, will try to predict my position but keeps me moving
at roughly the speed I exited the turn at. I.e. you seem to pull ahead on
the straight... phew! -NOT!!! -In fact, locally, I've got the pedal to the
metal and I'm steaming down the back stretch. By the time the next "hard"
position update from my machine reaches you, I have covered more ground than
you and am actually ahead of you on the track. Your client doesn't bat an
eyelid and shows me there... I have just magically jumped over your car.
Wrong order can explain the fast laps as reported by Andre. I can only
assume (and what follows is guesswork) GPL somehow timestamps the position
info it receives and then calculates your lap time based on where you were
first spotted across s/f and were last reported before s/f on each lap, with
corrections for how far you were actually from the line in each case. If, by
chance, 10 seconds after you actually crossed s/f GPL receives a delayed (or
garbled for that matter) packet that shows you closer to, but not before,
s/f than any other it has received yet, it may use this later timestamp to
calculate lap time.... you gain a magic 10 seconds elapsed time, because at
the next update, you shoot back up the track to where you actually were when
the faulty packet was received.
It might also be a case of data "overtaking" a delayed bunch, with that
bunch later being lost and/or ignored. Again a magic time gain is the
result. One stream of updates is almost immediately replaced with another,
but with a much later starting point, i.e. the track is effectively
shortened for you.
Let me take a moment to stress once again that this is just speculation on
my part. I certainly don't know how GPL works and I don't really know how
TCP/IP works: the only thing they ever told me was how the theoretical model
(the so called 7 layer OSI model) is supposed to work. In theory packets can
only get garbled and lost, they should arrive in the right order, but I also
know this is not the case in the real world. Whether I've hit the nail on
the head or whether I'm talking rubbish... I don't really know (sounds
plausible to me though) and I don't care. I wrote this to amuse myself and
maybe be of service to some others.
Cheers,
Jan.
----