diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index 6a5a3aa..05d7166 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -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`. diff --git a/src/main/java/com/gastinelgarde/core/VolVertical.java b/src/main/java/com/gastinelgarde/core/VolVertical.java index 67e81ce..21949ad 100644 --- a/src/main/java/com/gastinelgarde/core/VolVertical.java +++ b/src/main/java/com/gastinelgarde/core/VolVertical.java @@ -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; diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index ca90982..b930a18 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -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 diff --git a/src/test/java/com/gastinelgarde/core/MouvementTest.java b/src/test/java/com/gastinelgarde/core/MouvementTest.java index 4b20eef..b9d7e42 100644 --- a/src/test/java/com/gastinelgarde/core/MouvementTest.java +++ b/src/test/java/com/gastinelgarde/core/MouvementTest.java @@ -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 ---