From 9c2814a30ed7824449316cb61c70561304b3e359 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Fri, 16 Oct 2026 06:16:34 +0200 Subject: [PATCH] GastinelGarde vol : rafales reseau, ticks dus bornes (AVANCE_MAX = 4) Un paquet d un tick client recu apres n ticks serveur peut couvrir 1 tick ; les ticks dus sont couverts par les paquets a 0 tick suivants. Ensemble de ticks candidats = sur-ensemble de l ancien (jamais plus strict). Actif sans option : c est le correctif d un faux positif. 260 tests, 0 echec. Co-Authored-By: Claude Opus 5.5 --- .../com/gastinelgarde/core/VolVertical.java | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/src/main/java/com/gastinelgarde/core/VolVertical.java b/src/main/java/com/gastinelgarde/core/VolVertical.java index f00f1fd..f9f7af2 100644 --- a/src/main/java/com/gastinelgarde/core/VolVertical.java +++ b/src/main/java/com/gastinelgarde/core/VolVertical.java @@ -19,6 +19,15 @@ public final class VolVertical { private boolean etaitEnAir; private int anormauxConsecutifs; + /** + * Rafales réseau (16/10) : ticks serveur écoulés moins ticks client couverts par les paquets déjà vus. Un paquet + * d'un tick client reçu après 3 ticks serveur laisse 2 ticks « dus », couverts ensuite par les paquets à 0 tick de + * la même rafale. Borné à {@link #AVANCE_MAX} : au-delà, on revient à la règle stricte (n-1 ou n ticks), donc + * un client qui ralentit durablement sa chute (un tick de gravité toutes les 3 ticks) reste vu. + */ + public static final int AVANCE_MAX = 4; + private int avance; + // --- C10 (16/10) : option {@link GardeConfig#volFenetreGlissante}, désactivée par défaut --- /** Fenêtre glissante (ticks en l'air évalués) où l'on compte les ticks anormaux. */ public static final int FENETRE_TICKS = 20; @@ -53,6 +62,7 @@ public final class VolVertical { int n = e.ticks(); if (n > TICKS_MAX || n < 0) { aVitesse = false; + avance = 0; return 0; } boolean enAir = !e.auSolServeur(); @@ -62,11 +72,14 @@ public final class VolVertical { if (exempt || e.milieuSpecial() || !enAir) { anormauxConsecutifs = 0; + avance = 0; viderFenetre(); } else if (etaitEnAir && aVitesse) { // 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; + // Rafales : jusqu'à AVANCE_MAX ticks dus peuvent rester en attente ; la règle d'avant reste toujours admise. + int kMin = Math.max(1, Math.min(n <= 1 ? 1 : n - 1, n + avance - AVANCE_MAX)); int kMax = Math.max(1, n); + int kRetenu = kMax; boolean ecart = true; double v = derniereVitesse; double somme = 0; @@ -78,8 +91,10 @@ public final class VolVertical { if (k >= kMin && Math.abs(dy - somme) <= TOLERANCE * k) { ecart = false; vitesseFin = n <= 1 ? dy : v; + kRetenu = k; } } + avance = Math.max(0, Math.min(AVANCE_MAX, avance + n - kRetenu)); // 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); @@ -136,6 +151,7 @@ public final class VolVertical { aVitesse = false; etaitEnAir = false; anormauxConsecutifs = 0; + avance = 0; viderFenetre(); } }