GastinelGarde vol : tests C1-C5 inverses (CORRIGE_...), rouges avant correctif

Les tests FAUX_POSITIF_/FAILLE_ de l'incident VOL du 15/10 (C1, C2, C3, C4, C5)
exigent maintenant le bon comportement : grace de fin d'elytres, setback vers
une position au sol avec remise a zero du vol et des VL, escalade en plusieurs
setbacks, expulsion a usage unique, jamais de bannissement.
Squelette d'API sans effet dans Moteur et GardeConfig pour que les tests
compilent. Resultat : 253 tests, 5 echecs (attendus).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Opus 5.5 a révisé 2026-10-16 05:10:45 +02:00
1 Parent 44504eca0c
révision 56a98f3a5c
3 fichiers modifiés
+119 -81

Aucun fichier ne correspond à votre recherche

+8
Voir le fichier
@@ -17,6 +17,14 @@ public final class GardeConfig {
public double seuilExpulsion = 20.0;
/** Sanction la plus forte autorisée (T4 : setback puis expulsion, jamais de bannissement). */
public Sanction sanctionMax = Sanction.EXPULSION;
/**
* C5 (16/10) : un retour en arrière remet le VL du contrôle à zéro ; l'expulsion pour un contrôle de mouvement
* vient quand ce nombre de setbacks a déjà eu lieu dans {@link #fenetreSetbacksMs}.
*/
public int setbacksAvantExpulsion = 4;
public long fenetreSetbacksMs = 60_000;
/** C1 (16/10) : ticks de grâce du contrôle vol après la fin du plané en élytres (fin à l'atterrissage). */
public int graceFinElytresTicks = 50;
// --- Killaura ---
/** Angle maximal entre le regard et la silhouette de la cible, en degrés. */
+20
Voir le fichier
@@ -395,6 +395,26 @@ public final class Moteur {
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
}
// --- Setback, expulsion, position de retour (16/10, incident VOL) ----------------------------------------
/** Un retour en arrière vient d'être appliqué (squelette, pas encore de comportement). */
public void apresSetback(UUID joueur, long nowMs) {
}
/** Demande d'expulsion (squelette). */
public boolean expulser(UUID joueur, long nowMs) {
return true;
}
/** Reconnexion (squelette). */
public void oublierExpulsion(UUID joueur) {
}
/** La position de ce paquet peut-elle servir de retour en arrière ? (squelette) */
public boolean positionDeRetourAdmise(boolean auSolServeur, boolean milieuSpecial) {
return true;
}
// --- Interne ----------------------------------------------------------------------------------------
private void ajouter(List<Verdict> sortie, Suivi s, Controle c, double points, long nowMs,
+91 -81
Voir le fichier
@@ -14,9 +14,9 @@ import org.junit.jupiter.api.Test;
/**
* Autotests du 16/10/2026, nuit : incident VOL de Rednixxu (15/10, 17:31) et constats C1 à C5, C10 de l'autocritique.
*
* Ces tests DOCUMENTENT le comportement actuel, ils ne corrigent rien : un test nommé {@code FAILLE_…} ou
* {@code FAUX_POSITIF_…} passe tant que le défaut existe. Quand le défaut sera corrigé, il échouera : il faudra alors
* inverser son assertion (c'est voulu, pour que la correction soit vue).
* C1 à C5 corrigés le 16/10 (branche fix/vol-elytres) : les anciens tests {@code FAUX_POSITIF_…} / {@code FAILLE_…}
* ont été inversés et renommés {@code CORRIGE_…}. C10 n'est pas corrigé : ses tests {@code FAILLE_…} passent tant que
* le défaut existe.
*
* Ce qui se passe dans l'adaptateur (Garde.java, qui dépend de Minecraft) est rejoué ici par un petit modèle écrit
* d'après le code : position mémorisée après un paquet sans verdict (Garde.apresMouvement), paquet suivant un
@@ -67,7 +67,8 @@ class AutotestVolIncidentTest {
tick++;
y += m.dy();
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, e, m);
if (vs.isEmpty()) { // Garde.apresMouvement : m.dernierVerdictTick != tick
// Garde.apresMouvement : m.dernierVerdictTick != tick, et (16/10, C3) position admise (au sol serveur)
if (vs.isEmpty() && moteur.positionDeRetourAdmise(m.auSolServeur(), m.milieuSpecial())) {
yRetour = y;
retourAuSol = m.auSolServeur();
}
@@ -94,24 +95,41 @@ class AutotestVolIncidentTest {
return sortie;
}
// --- C1 : pas de grâce de sortie d'élytres pour le vol ----------------------------------------------------------
/** Plané anormal depuis le sol, sans élytres (triche de type « glide ») : de quoi déclencher des setbacks. */
private EtatMouvement plane() {
return air(-0.02);
}
// --- C1 : grâce de sortie d'élytres pour le vol (corrigé le 16/10) ----------------------------------------------
@Test
void FAUX_POSITIF_C1_planeDElytresDontLeDrapeauTombeEstPrisPourDuVol() {
void CORRIGE_C1_planeDElytresDontLeDrapeauTombeNEstPlusPrisPourDuVol() {
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
int premier = -1;
double total = 0;
for (int k = 0; k < vs.size(); k++) {
double p = points(vs.get(k), Controle.VOL);
if (p > 0 && premier < 0) premier = k + 1;
total += p;
}
// Prouvé : le 1er paquet après l'exemption sert de référence, les suivants sont tous « anormaux » ; le 12e tick
// de plané sans drapeau donne le premier point (journal réel : 13 ticks après la chute du drapeau, vl=1.1).
assertEquals(12, premier, "premier tick de plané puni");
assertEquals(1.1, points(vs.get(11), Controle.VOL), 1e-9);
assertTrue(total > cfg.seuilSetback, "19 ticks de plané suffisent à dépasser le seuil de setback");
Mesures.noter("C1 premier point au tick " + premier + " de plane sans drapeau ; total 19 ticks = " + total);
for (List<Verdict> v : vs) total += points(v, Controle.VOL);
// Avant : premier point au 12e tick, 11,6 points en 19 ticks (incident de Rednixxu).
assertEquals(0, total, 1e-9, "grâce de fin d'élytres : la trace de Rednixxu ne donne plus rien");
Mesures.noter("C1 corrige : 19 ticks de plane sans drapeau = " + total + " point");
}
@Test
void CORRIGE_C1_laGraceDeFinDElytresEstBorneeDansLeTemps() {
// Témoin : un plané sans drapeau qui dure bien au-delà de la grâce finit par être vu.
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(cfg.graceFinElytresTicks + 30);
double total = 0;
for (List<Verdict> v : vs) total += points(v, Controle.VOL);
assertTrue(total > 0, "après la grâce, un plané anormal est de nouveau puni");
}
@Test
void CORRIGE_C1_laGraceSeTermineALAtterrissage() {
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
for (int i = 0; i < 20; i++) paquet(elytres, air(-0.3));
for (int i = 0; i < 3; i++) paquet(EtatJoueur.normal(), sol()); // atterrissage : fin de la grâce
double total = 0;
for (int i = 0; i < 20; i++) total += points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL);
assertTrue(total > 0, "voler juste après un atterrissage d'élytres reste vu");
}
@Test
@@ -127,102 +145,94 @@ class AutotestVolIncidentTest {
assertEquals(0, total, 1e-9, "réfuté : une fin d'élytres suivie d'une chute vanilla ne donne rien");
}
// --- C3 : point de retour mémorisé en l'air -----------------------------------------------------------------------
// --- C3 : point de retour au sol (corrigé le 16/10) --------------------------------------------------------------
@Test
void FAUX_POSITIF_C3_pointDeRetourMemoriseEnLAirSousLaPlateforme() {
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(12);
assertTrue(points(vs.get(11), Controle.VOL) > 0);
assertFalse(retourAuSol, "la position de retour vient d'un paquet en l'air");
assertTrue(yRetour < Y_SOL, "et elle est sous la plateforme d'où il a sauté : " + yRetour);
Mesures.noter(String.format(java.util.Locale.ROOT,
"C3 retour en l'air a y=%.3f (sol %.3f, ecart %.3f ; journal reel : 109,685, ecart 1,19)",
yRetour, Y_SOL, Y_SOL - yRetour));
void CORRIGE_C3_pointDeRetourResteAuSolPendantUnPlane() {
sautPuisPlaneSansDrapeau(12);
assertTrue(retourAuSol, "la position de retour vient d'un paquet au sol serveur");
assertEquals(Y_SOL, yRetour, 1e-9, "et c'est la plateforme d'où il a sauté");
}
@Test
void FAILLE_C3_unVolDeDixTicksGardeLAltitudeGagneeDansLePointDeRetour() {
void CORRIGE_C3_unVolDeDixTicksNeGardePasLAltitudeGagnee() {
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
int premier = -1;
for (int k = 1; k <= 15 && premier < 0; k++) {
if (points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL) > 0) premier = k;
}
assertTrue(premier > 10, "le vol n'est vu qu'après 10 ticks anormaux");
assertFalse(retourAuSol);
assertTrue(yRetour - Y_SOL >= 0.9, "le setback ramène à l'altitude gagnée en volant : +" + (yRetour - Y_SOL));
Mesures.noter(String.format(java.util.Locale.ROOT, "C3 tricheur : retour a +%.2f bloc au-dessus du sol",
yRetour - Y_SOL));
assertTrue(retourAuSol);
assertEquals(Y_SOL, yRetour, 1e-9, "le setback ramène au sol de départ, pas à l'altitude gagnée");
}
// --- C2, C5, C4 : setback sans remise à zéro, escalade en moins d'une seconde, expulsion répétée ------------------
// --- C2, C5, C4 : setback remis à zéro, escalade, expulsion unique (corrigés le 16/10) ---------------------------
@Test
void FAUX_POSITIF_C2_setbackNOuvreAucuneGraceEtNeRemetPasLeVolAZero() {
GraceTeleport g = new GraceTeleport();
g.annoncer(GraceTeleport.Origine.SETBACK);
assertFalse(g.teleport(), "le setback n'ouvre pas la grâce de téléportation");
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
int k = 0;
while (Verdict.pire(vs.get(k)) != Sanction.SETBACK) k++; // premier SETBACK
// Modèle de l'adaptateur : teleport() vers le point de retour ; le paquet suivant n'est pas mesuré.
tick++;
/** Modèle de Garde.appliquerSanctionMouvement (SETBACK) : téléportation au point de retour puis remise à zéro. */
private void setback() {
moteur.apresSetback(joueur, tick * 50L);
tick++; // teleport() : le paquet suivant n'est pas mesuré (Garde.teleportVanilla)
y = yRetour;
// Joueur gelé en l'air au point de retour (dy = 0, gravité absente tant que la téléportation n'est pas
// confirmée : « kicked for floating too long » x302 dans le journal du 15/10).
for (int i = 0; i < 5; i++) {
List<Verdict> v = paquet(EtatJoueur.normal(), air(0));
assertTrue(points(v, Controle.VOL) > 0, "paquet gelé " + i + " après le setback encore puni");
}
}
@Test
void FAUX_POSITIF_C5_C4_cinqSetbacksPuisExpulsionEnMoinsDUneSecondeEtExpulsionRepetee() {
void CORRIGE_C2_apresUnSetbackLeVolEtLesVlRepartentDeZero() {
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
double v = 0.42;
int n = 0;
while (Verdict.pire(paquet(EtatJoueur.normal(), plane())) != Sanction.SETBACK) assertTrue(++n < 100);
assertTrue(retourAuSol, "point de retour au sol");
setback();
assertEquals(0, moteur.suivi(joueur).vl.valeur(Controle.VOL, tick * 50L), 1e-9, "VL de vol remis à zéro");
// Le client, ramené au sol, reste immobile quelques paquets (téléportation pas encore confirmée) : rien.
for (int i = 0; i < 5; i++) {
paquet(EtatJoueur.normal(), air(v));
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
List<Verdict> v = paquet(EtatJoueur.normal(), sol());
assertEquals(0, points(v, Controle.VOL), 1e-9, "paquet " + i + " après le setback");
}
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
for (int i = 0; i < 7; i++) paquet(elytres, air(-0.05));
// Et même gelé en l'air une demi-seconde (ancien scénario), le compteur repart de zéro : pas de point.
double total = 0;
for (int i = 0; i < 10; i++) total += points(paquet(EtatJoueur.normal(), air(0)), Controle.VOL);
assertEquals(0, total, 1e-9);
}
@Test
void CORRIGE_C5_C4_escaladeEnPlusDUneSecondeEtExpulsionUnique() {
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
int premierPointTick = -1, setbacks = 0, expulsionTick = -1;
double dyPlane = 0;
boolean gele = false;
for (int n = 0; n < 200 && expulsionTick < 0; n++) {
EtatMouvement m;
if (gele) {
m = air(0);
} else {
dyPlane -= 0.02;
m = air(dyPlane);
}
List<Verdict> vs = paquet(EtatJoueur.normal(), m);
for (int n = 0; n < 2000 && expulsionTick < 0; n++) {
List<Verdict> vs = paquet(EtatJoueur.normal(), plane());
if (points(vs, Controle.VOL) > 0 && premierPointTick < 0) premierPointTick = tick;
Sanction s = Verdict.pire(vs);
if (s == Sanction.SETBACK) {
setbacks++;
gele = true;
tick++; // teleport() : le paquet suivant n'est pas mesuré (Garde.teleportVanilla)
y = yRetour;
setback();
paquet(EtatJoueur.normal(), sol()); // de retour au sol, le tricheur recommence
} else if (s == Sanction.EXPULSION) {
expulsionTick = tick;
}
}
assertTrue(expulsionTick > 0, "expulsion atteinte");
assertTrue(expulsionTick > 0, "un tricheur obstiné finit expulsé");
int duree = expulsionTick - premierPointTick;
Mesures.noter("C5 premier point -> expulsion : " + duree + " ticks (" + duree * 50 + " ms), " + setbacks
+ " setbacks (journal reel : 5 setbacks, expulsion a la 1re seconde)");
assertTrue(duree < 20, "moins d'une seconde entre le premier point et l'expulsion : " + duree + " ticks");
assertTrue(setbacks >= 3 && setbacks <= 6, "quelques setbacks seulement : " + setbacks);
Mesures.noter("C5 corrige : premier point -> expulsion : " + duree + " ticks (" + duree * 50 + " ms), "
+ setbacks + " setbacks");
assertTrue(duree >= 40, "au moins 2 s entre le premier point et l'expulsion : " + duree + " ticks");
assertEquals(cfg.setbacksAvantExpulsion, setbacks, "l'expulsion vient après plusieurs setbacks distincts");
// C4 (partie moteur) : rien ne retient « déjà expulsé » ; chaque paquet suivant redonne une EXPULSION.
int expulsionsSuivantes = 0;
for (int i = 0; i < 20; i++) {
if (Verdict.pire(paquet(EtatJoueur.normal(), air(0))) == Sanction.EXPULSION) expulsionsSuivantes++;
}
assertEquals(20, expulsionsSuivantes, "chaque paquet après l'expulsion rend encore EXPULSION");
// C4 : l'expulsion est à usage unique ; le moteur ne rend plus rien pour ce joueur.
assertTrue(moteur.expulser(joueur, tick * 50L), "première expulsion acceptée");
assertFalse(moteur.expulser(joueur, tick * 50L), "deuxième demande refusée");
int verdictsSuivants = 0;
for (int i = 0; i < 20; i++) verdictsSuivants += paquet(EtatJoueur.normal(), plane()).size();
assertEquals(0, verdictsSuivants, "aucun verdict après l'expulsion");
// C6 : même si l'état du joueur est retiré pendant disconnect(), la marque d'expulsion reste.
moteur.retirer(joueur);
assertFalse(moteur.expulser(joueur, tick * 50L));
moteur.oublierExpulsion(joueur); // reconnexion
assertTrue(moteur.expulser(joueur, tick * 50L));
}
@Test
void jamaisDeBannissement() {
for (Sanction s : Sanction.values()) assertFalse(s.name().contains("BAN"), "sanction " + s);
}
@Test