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 à :
1 Parent
5f1f09afa9
révision
d3f56892a4
4 fichiers modifiés
+88
-9
Aucun fichier ne correspond à votre recherche
@@ -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;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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 ---
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur