F08 : le controle de vol s'evalue quel que soit l'ecart entre paquets

Prediction iteree sur les ticks ecoules, jitter de +-1 tick tolere. 113 tests.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Opus 5.5 a révisé 2026-10-14 08:39:42 +02:00
1 Parent 5f1f09afa9
révision d3f56892a4
4 fichiers modifiés
+88 -9

Aucun fichier ne correspond à votre recherche

+6 -1
Voir le fichier
@@ -13,7 +13,7 @@ Base avant corrections : 98 tests verts.
| F05 grâce téléportation | corrigée | `git log --grep F05` | `AuditFaillesTest.F05_*` (2) ; 106 verts | essai en jeu : `/tp`, perle, TPA, portail sans fausse alerte |
| F06 grâce dégâts | corrigée | `git log --grep F06` | `AuditFaillesTest.F06_*`, `AdaptateursTest.F06_*` ; 109 verts | essai en jeu : Wind Charge, explosion, coup d'épée : aucune fausse alerte |
| F07 ping | corrigée | `git log --grep F07` | `AuditFaillesTest.F07_*`, `ExemptionsTest.lagAugmenteLaTolerance` (assertion inversée) ; 110 verts | essai en jeu n° 3 ; mesurer dans les traces si un joueur honnête en wifi médiocre lève des fausses alertes |
| F08 vol aveugle | à faire | | | |
| F08 vol aveugle | corrigée | `git log --grep F08` | `AuditFaillesTest.F08_*` (2), `MouvementTest` (ancien test de l'angle mort inversé, +1) ; 113 verts | essai en jeu n° 12 ; vérifier dans les traces qu'une chute honnête avec lag ne lève pas `vol` |
| F02 timer inondation | à faire | | | |
| F12 cadence saturée | à faire | | | |
| F13 cibles saturées | à faire | | | |
@@ -49,3 +49,8 @@ Base avant corrections : 98 tests verts.
### F07
- `Exemptions` : le facteur ×1,5 ne dépend plus que du TPS (mesuré par le serveur). Le ping (keep-alive, retardable par le client) reste dans `EtatJoueur` pour le journal et les traces. La clé `pingLagMs` est gardée dans la configuration (commentée « ignorée ») pour ne pas casser les fichiers existants.
- Vérifié : les autres grâces sont mesurées par le serveur (gel : durée du tick ; TPS : moyenne serveur ; téléportation : F05 ; recul : F06 ; riptide : F04).
### F08
- `VolVertical` : la prédiction `vy' = (vy − 0,08) × 0,98` est itérée sur les ticks écoulés (jusqu'à 40 ; au-delà, lag : on oublie la vitesse comme avant). Jitter toléré : un paquet en retard de n ticks peut couvrir n−1 ou n ticks ; un paquet à 0 tick (deuxième du même tick) en couvre 1. Tolérance 0,05 × ticks.
- Couvre aussi le joueur immobile en l'air qui n'envoie plus que le rappel de position toutes les 20 ticks.
- L'ancien test `paquetsManquantsNeFontPasDInfraction` affirmait l'angle mort : inversé en `paquetsEspacesEnVolStationnaireSontVus`.
+27 -6
Voir le fichier
@@ -19,26 +19,47 @@ public final class VolVertical {
private boolean etaitEnAir;
private int anormauxConsecutifs;
/** Au-delà, l'écart entre deux paquets est trop grand pour prédire (lag) : on oublie la vitesse. */
public static final int TICKS_MAX = 40;
/**
* F08 : avant, seul un écart d'exactement 1 tick était évalué ; un client qui envoyait un paquet tous les
* 2 ticks (ou le rappel de position toutes les 20 ticks d'un joueur immobile en l'air) n'était jamais vu.
* La prédiction est maintenant itérée sur les ticks écoulés, avec ±1 tick de jitter : un paquet en retard
* couvre un tick de moins que l'écart serveur, et le paquet suivant du même tick (0 tick) en couvre un.
*
* @param exempt joueur exempté du mouvement
* @return points d'infraction (0 si rien)
*/
public double enregistrer(EtatMouvement e, boolean exempt) {
// Paquets groupés ou manquants : la prédiction d'un tick ne vaut plus, on oublie la vitesse précédente.
if (e.ticks() != 1) {
int n = e.ticks();
if (n > TICKS_MAX || n < 0) {
aVitesse = false;
return 0;
}
boolean enAir = !e.auSolServeur();
double dy = e.dy();
double points = 0;
double vitesseFin = n <= 1 ? dy : dy / n;
if (exempt || e.milieuSpecial() || !enAir) {
anormauxConsecutifs = 0;
} else if (etaitEnAir && aVitesse) {
double prevue = (derniereVitesse - GRAVITE) * TRAINEE;
boolean ecart = Math.abs(dy - prevue) > TOLERANCE;
// Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08.
// Ticks candidats couverts par ce paquet : n exactement à l'heure ; n-1 ou n en retard ; 1 si 0.
int kMin = n <= 1 ? 1 : n - 1;
int kMax = Math.max(1, n);
boolean ecart = true;
double v = derniereVitesse;
double somme = 0;
for (int k = 1; k <= kMax; k++) {
v = (v - GRAVITE) * TRAINEE;
somme += v;
if (k >= kMin && Math.abs(dy - somme) <= TOLERANCE * k) {
ecart = false;
vitesseFin = n <= 1 ? dy : v;
}
}
// Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08 par tick.
if (ecart) anormauxConsecutifs++;
else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1);
if (anormauxConsecutifs > TICKS_ANORMAUX) {
@@ -46,7 +67,7 @@ public final class VolVertical {
}
}
derniereVitesse = dy;
derniereVitesse = vitesseFin;
aVitesse = true;
etaitEnAir = enAir;
return points;
+41
Voir le fichier
@@ -164,6 +164,47 @@ class AuditFaillesTest {
Exemptions.Famille.MOUVEMENT).facteur(), 1e-9, "le TPS bas, mesuré par le serveur, tolère encore");
}
// ---------------------------------------------------------------- F08
/** Avant : le contrôle de vol ne s'évaluait que si exactement 1 tick séparait deux paquets. */
@Test
void F08_vol_vu_quel_que_soit_l_ecart_entre_paquets() {
for (int ecart : new int[] {1, 2, 3, 20}) {
UUID a = UUID.randomUUID();
boolean vu = false;
long now = 0;
for (int i = 0; i < 60; i++) {
if (contient(moteur.mouvement(a, now, EtatJoueur.normal(), mv(0, 0, ecart, false, false)), Controle.VOL)) vu = true;
now += 50L * ecart;
}
assertTrue(vu, "hover avec un paquet tous les " + ecart + " ticks : vu");
}
}
/** Une chute honnête avec du jitter réseau (paquets en retard puis groupés) ne doit pas lever le vol. */
@Test
void F08_chute_honnete_avec_jitter_sans_fausse_alerte() {
UUID a = UUID.randomUUID();
double v = 0;
boolean vu = false;
long now = 0;
int tick = 0;
// 80 ticks de chute (avec un peu d'élan initial), paquets : à l'heure, en retard (2 ticks), puis groupé (0 tick)
int[] motif = {1, 1, 2, 0, 1, 3, 0, 0, 1};
double[] dyTick = new double[200];
for (int k = 0; k < dyTick.length; k++) { v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE; dyTick[k] = v; }
int couvert = 0;
for (int p = 0; couvert < 80; p++) {
int n = motif[p % motif.length];
int clientTicks = n == 0 ? 1 : (n >= 2 ? n - 1 : 1); // en retard : couvre un tick de moins
double dy = 0;
for (int c = 0; c < clientTicks; c++) dy += dyTick[couvert++];
tick += n;
now = tick * 50L;
if (contient(moteur.mouvement(a, now, EtatJoueur.normal(), mv(0, dy, n, false, false)), Controle.VOL)) vu = true;
}
assertFalse(vu, "chute vanilla avec jitter : aucune infraction vol");
}
// ---------------------------------------------------------------- F06
/**
* Avant : tout dégât (feu, cactus, wither) ouvrait 20 ticks de grâce ; se blesser chaque seconde exemptait en
+14 -2
Voir le fichier
@@ -186,14 +186,26 @@ class MouvementTest {
}
@Test
void paquetsManquantsNeFontPasDInfraction() {
void paquetsEspacesEnVolStationnaireSontVus() {
// F08 : avant, un paquet tous les 3 ticks n'était jamais évalué (cette situation était l'angle mort).
VolVertical vol = new VolVertical();
double max = 0;
for (int i = 0; i < 40; i++) {
EtatMouvement e = new EtatMouvement(0.2, 0.0, 3, false, false, false, false, false, 0, 0, false, false);
max = Math.max(max, vol.enregistrer(e, false));
}
assertEquals(0, max, 1e-9);
assertTrue(max > 0);
}
@Test
void ecartTropGrandOublieLaVitesse() {
VolVertical vol = new VolVertical();
double max = 0;
for (int i = 0; i < 40; i++) {
EtatMouvement e = new EtatMouvement(0.2, 0.0, VolVertical.TICKS_MAX + 1, false, false, false, false, false, 0, 0, false, false);
max = Math.max(max, vol.enregistrer(e, false));
}
assertEquals(0, max, 1e-9, "plus de 2 s entre deux paquets : lag, pas de prédiction");
}
// --- Moteur ---