[PAWN] Anti Lag System explained

Tutorial on how to make something lag-proof. Calculations done by me, scripting is up to you!



A player is moving. His position in his client is 'O'. He lags, so the server gets a previous position, the position of the player <ping> milliseconds earlier. This is position 'P'. Position P is also the position you get using GetPlayerPos

P-------------------O

The player reaches a velocity 'V'

P------------------O------V

When in the velocity, nothing happens. The server doesn't know yet he's in the velocity.

P-----------------O
                  V

The server sends the velocity to the player when point 'P' is at 'V' (definition of P: position the server retrieves at the moment the player is at 'O')

P----------------O
V
>server sends velocity

The velocity reaches the player after <ping> milliseconds.

V----------------P----------------O
>player gets velocity

The player is - in his client - much further.


We can adjust this by calculating the O. If we multiply his ping by his velocity, we get the distance between 'P' and 'O'. We'll name this 'R'.

>> R = P + ping*velocity

P-------------------O
                    R

The player reaches a velocity 'V'

P------------------O------V
                   R

When in the velocity, the server sends the velocity due to the adjusted position 'R'

P------------------O
                   R
                   V
>server sends velocity

The velocity reaches the player after <ping> milliseconds. This is (when the ping remains the same) the same distance as |PO|.

P------------------O
V                  R
>player gets velocity

The player is - in his client - a little further.

We can calculate yet another position, his future position 'F'.

>> F = R + ping*velocity = P + ping*velocity*2

P-------------------O-------------------F
                    R

The player gets close to a velocity 'V'

P-------------------O-------------------F---V
                    R

When his future position is in 'V', we let the server send him the velocity

P-------------------O-------------------F
                    R                   V
>server sends velocity

The player recieves the velocity |PO| = |OF| later.

P-------------------O-------------------F
                    R
                    V
>player gets the velocity

This is exactly how we want it.

To do this, we'll need to adjust GetPlayerPos by changing the callbacks and functions.
Though I'm not sure if you can call the real function within the adjusted functions.

eg
GetPlayerPos(playerid, X, Y, Z) {
  GetPlayerPos(playerid, x, y, z); // the default player pos -> this is where I doubt it'll work
  GetPlayerVelocity(playerid, vx, vy, vz);
  new p = GetPlayerPing(playerid);
  X = x + vx*p*2;
  Y = y + vy*p*2;
  Z = z + vz*p*2;
}

The problem is other callbacks/functions use GetPlayerPos internally. An example is: IsPlayerInRangeOfPoint.

IsPlayerInRangeOfPoint(playerid, Float:range, Float:x, Float:y, Float:z)
-> internally it gets the player position using the playerid.

This can be adjusted as well, though it'll be a lot harder. Another option would be to adjust the range instead of the player position - that'll use a lot less resources and won't blow my mind during the calculations of creating a sphere (because that's what the function does).

If we set the range
>>range = default range + ping*velocity*2;

I think that will work as well. You can adjust most functions using this method.

OnPlayerEnterCheckpoint however and other related callbacks will be a bigger problem though, as they use nothing but the playerid.

--------------------------------------------------------------

Testing showed that the theoretical value 2 (one to send the info to the server and one to get the server info) is incorrect. Apparently some more stuff happens. The value is estimated between 40 and 50. Try on people with a high ping and check what works out best.

>>range = default range + ping*velocity*40;
>>range = default range + ping*velocity*50;