Les mécanismes de compensation réseau

Le jeu en réseau souffre de nombreuses contraintes dues à la nature même de ces réseaux, peu adaptés à cette utilisation nécessitant de délivrer des paquets de données à fréquence fixe avec une latence minimale. Cela est surtout vrai pour les connexions RTC et les connexions ADSL dénuées de la technologie FastPath.

Pour cette raison, il a fallu développer des mécanismes "artificiels" pour compenser ces limitations. Pour le moteur Source, 3 de ces mécanismes sont implémentés : l’interpolation et la prédiction côté client, et le lag compensation côté serveur.



La prédiction

Il s’agit du mécanisme le plus simple. Il a pour objectif de rendre le jeu plus "réactif" aux actions du joueur et est implémenté côté client.
Sans la prédiction, le client affiche ce qu’il reçoit du serveur par les mises à jour et uniquement cela. Ce qui signifie que si vous tirez, le jeu ne déclenchera l’animation et les effets correspondants que lorsqu’il aura reçu confirmation de ce tir par le serveur. Cela nuit considérablement à la jouabilité car entraîne un décalage entre le moment où vous tirez et le moment où vous voyez ce tir sur l’écran.
Pour éviter ce problème, le jeu va anticiper la confirmation du serveur : c’est la prédiction. En clair, le jeu va tirer sans attendre la confirmation. Ce qui signifie que lorsque vous voyez l’animation de tir de votre arme, le tir a en réalité été pris en compte quelques millisecondes plus tard sur le serveur (votre latence), ce décalage étant compensé par le lag compensation que nous verrons plus tard.
La prédiction est surtout utile sur les actions de tir et de déplacement. Mais il peut arriver que cette "anticipation" ne soit pas correcte et que l’action ne se produise pas sur le serveur (ou d’une manière différente). Cela arrive notamment si vous tirez et que quelqu’un vous tue pendant le trajet de l’information de tir jusqu’au serveur : en réalité, votre tir n’a pas été pris en compte. Ces différences entre ce que le client s’attend à recevoir et ce qu’il reçoit réellement sont appelées erreurs de prédiction. Elles sont visibles grâce à la CVAR cl_showerror (uniquement si sv_cheats est à 1 sur le serveur). Le client se replacera alors sur l’état indiqué par le serveur (puisque celui-ci a autorité sur le jeu). Ces erreurs de prédiction arrivent en général peu fréquemment, et leurs conséquences sont souvent négligeables.

Lorsque l’erreur de prédiction est minime (une très légère différence de direction lors d’un déplacement par exemple), votre client va "smoother" c’est à dire "adoucir" la correction de l’erreur. Par exemple, si la prédiction d’un de vos mouvements s’est fait légèrement trop à droite par rapport à la confirmation du serveur, votre jeu vous replacera "doucement" vers la bonne position, de sorte que vous ne vous en rendrez même pas compte.

Si l’erreur est grande (c’est à dire lorsque le temps nécessaire pour "l’adoucir" dépasse la valeur de la CVAR client cl_smoothtime), le client va vous replacer brutalement à la bonne position : c’est ce phénomène que vous pouvez voir quand vous revenez brusquement un pas en arrière au cours d’un rush par exemple (un ami appelait ça des phénomènes de "back-vidéo").

La fréquence et la gravité des erreurs de prédiction dépend de votre latence et de la fréquence de vos mises à jour (dans les deux sens), ainsi que de la qualité du serveur.

La prédiction est désactivable avec la CVAR cl_predict. Cependant, cela ne présente aucun intérêt.



L’interpolation

Par défaut, votre updaterate ne peut pas dépasser 20 (cl_updaterate). Ce qui signifie que vous recevrez, pour un joueur précis, 20 fois sa position par seconde.

Si il n’y avait pas d’interpolation, ce joueur, lors de ses déplacements, changerait de position 20 fois par seconde sur la vue du client, ce qui équivaut à avoir 20 images par seconde de ce joueur. D’où des saccades d’affichage. Et augmenter l’ updaterate ne corrige pas grand chose dans la plupart des cas, vu que ces saccades seront dans ce cas dues au cmdrate trop faible du joueur que vous regardez.
L’interpolation va "inventer" des points du joueur situés entre deux positions. Ainsi, si vous avez 85 images par seconde lorsque vous jouez et que le joueur que vous regardez change 20 fois de position par seconde, 65 points seront "inventés" par l’interpolation pour fluidifier son mouvement.

L’interpolation s’effectue sur un intervalle de temps fixe réglable avec la CVAR cl_interp (en secondes, 0 pour désactiver l’interpolation). Par défaut, l’interpolation s’effectue sur 100 millisecondes (cl_interp 0.1).
L’interpolation induit donc forcément un décalage de temps entre la vue du client et les mises à jour que celui-ci reçoit, compensé par le lag compensation que nous verrons plus tard.



Interpolation et cmdrate : le problème de la "touchabilité"

L’interpolation invente des points qui n’existent pas. Le fait que ces points n’existent pas peut être dû à votre updaterate trop bas, dans ce cas le serveur aura plus de points que vous sur le déplacement d’un joueur précis.

Mais imaginons que l’interpolation se fasse sur le mouvement d’un joueur dont le cmdrate est plus bas que le tickrate du serveur (par exemple un joueur avec le cmdrate par défaut 30 et un serveur de tickrate 66). Le client va inventer des points qui n’existent pas pour le serveur. Ce fait qui paraît logique (et qui l’est) peut avoir des conséquences néfastes sur la "touchabilité" d’un joueur, c’est à dire vos chances de l’abattre lorsque celui ci est en mouvement. En effet, si vous tirez sur une hitbox "inventée" par l’interpolation, c’est à dire ne correspondant pas avec sa position réelle sur le serveur, vous ne la toucherez pas car sa position réelle est différente.

Imaginons une situation similaire à celle prise comme exemple pour le tickrate : un contre-terroriste se déplace dans le champ de vision d’un terroriste. Celui-ci lui lui tire dessus à mi-chemin. On fait abstraction du lag et du décalage induit par l’interpolation, tous deux compensés par le lag compensation. On considère également que le tickrate du serveur est supérieur à 40 et que l’updaterate ainsi que le cmdrate du terroriste sont également supérieurs à 40.

Nous allons comparer plusieurs situations où on fait varier le cmdrate du contre-terroriste ainsi que l’interpolation.




Avec un cmdrate de 40 (intervalle : 25 ms), interpolation activée
Avec un cmdrate de 20 (intervalle : 50 ms), interpolation activée


Comme vous pouvez le voir, la position du contre-terroriste à 25 ms a été interpolée en raison de son cmdrate trop faible : le joueur a tiré sur un point qui n’existe pas sur le serveur, l’impact n’est pas pris en compte.

Avec un cmdrate de 20 (intervalle : 50 ms), interpolation désactivée



L’interpolation étant désactivée, le terroriste voit le contre-terroriste à la même position à 0 comme à 25 ms, c’est à dire la position réelle du contre-terroriste : il tire sur cette position et l’impact est bien pris en compte.

NOTE : comme pour le tickrate, cet exemple doit être relativisé. En effet le rapport taille des hitboxes/distance parcourue présenté ici est totalement différent.

Nous sommes donc dans la situation suivante : si le tireur a l’interpolation activée, plus l’adversaire aura un cmdrate bas, moins celui-ci sera "touchable" par le tireur. Mais ce cmdrate bas peut aussi entraîner des effets néfastes :


  • Si le terroriste est immobile et que le contre-terroriste est en mouvement (notre exemple), le cmdrate bas du contre-terroriste lui sera profitable car il diminuera la "touchabilité" du terroriste.
  • Si le terroriste et le contre-terroriste sont immobiles, le cmdrate du contre-terroriste ne joue pas.
  • Si le terroriste est en mouvement et que le contre-terroriste est immobile, le contre-terroriste sera pénalisé par son cmdrate bas, car il enverra à une fréquence plus basse ses informations de tir pour toucher le terroriste en mouvement.

On peut donc en conclure que fixer un cmdrate bas et rester en mouvement vous rend moins vulnérable face à un adversaire qui a son interpolation activée. Au contraire, si vous restez immobile et que vous essayez d’abattre un adversaire en mouvement, le cmdrate bas vous pénalisera dans tous les cas. Cela explique le fait que certains joueurs ont de meilleurs scores avec un cmdrate de 10 qu’avec un cmdrate de 100.

La meilleure solution pour éviter de se faire avoir par un cmdrate bas est donc de désactiver l’interpolation (cl_interp 0). L’affichage des entités et des joueurs sera alors plus saccadé mais retranscrira exactement le contenu des mises à jour, donc tous les points affichés seront les mêmes que sur le serveur.


Le lag compensation

Il nous reste un problème à résoudre, fondamental dans les jeux en réseau : la latence. En effet, tirer sur un joueur en mouvement avec un ping de 80 ms sans mécanisme de compensation adapté oblige à viser au-devant de l’ennemi, ce qui n’est pas vraiment satisfaisant du point de vue de la crédibilité de la simulation.

Alors comment le serveur fait-il pour compenser cette latence ? Eh bien il remonte le temps. En effet, tout le principe du lag compensation consiste à estimer à quel moment le joueur a réellement tiré (ou plus précisément : le moment auquel l’image sur laquelle le joueur a tiré s’est affichée). Une fois ce moment déterminé, le serveur va remonter dans un "historique" des précédents ticks. Une fois le tick correspondant isolé, il va l’utiliser pour déterminer si, dans cette "image du jeu", le joueur a touché son adversaire ou pas.

Avant de continuer, rappelons que la latence (le ping) est exprimé dans un délai aller et retour. Quels éléments le serveur doit-il prendre en compte lors de l’estimation du décalage entre le serveur et le client ?

  • Le temps d’arrivée des mises à jour serveur vers client.
  • L’interpolation (si elle est activée), qui crée un décalage supplémentaire.
  • Le temps d’arrivée des commandes client.

Ce qui nous donne : temps d’arrivée des mises à jour + temps d’interpolation + temps d’arrivée des commandes client = lag à compenser, soit latence + temps d’interpolation = lag à compenser.





Dans l’exemple ci-dessus (tickrate 66), le joueur a tiré alors qu’il voyait une mise à jour générée au tick 1. Au moment où il a "vu" ce tick, il était déjà en décalage avec le serveur de 140 ms (temps d’arrivée de la mise à jour + interpolation). Ajoutons à cela les 40 ms pour le parcours de la commande et on obtient 140 + 40 = 180 ms à remonter. Le décalage maximal compensable par le serveur est paramétrable avec la CVAR sv_maxunlag (en secondes, par défaut 1).

Le serveur sait qu’il y a 180 ms il en était au tick 1, donc il se sert de ce tick pour déterminer si le joueur a touché sa cible ou non. Si oui, l’impact est comptabilisé pour le tick 13.

Le lag compensation est désactivable avec la CVAR sv_unlag. Cependant le faire est très fortement déconseillé.