diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index d6ccff1..732aef3 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -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. */ diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index a3d9815..9ce287f 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -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 sortie, Suivi s, Controle c, double points, long nowMs, diff --git a/src/test/java/com/gastinelgarde/core/AutotestVolIncidentTest.java b/src/test/java/com/gastinelgarde/core/AutotestVolIncidentTest.java index 3e7e98e..34060e7 100644 --- a/src/test/java/com/gastinelgarde/core/AutotestVolIncidentTest.java +++ b/src/test/java/com/gastinelgarde/core/AutotestVolIncidentTest.java @@ -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 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> 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 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> vs = sautPuisPlaneSansDrapeau(cfg.graceFinElytresTicks + 30); + double total = 0; + for (List 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> 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> 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 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 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 vs = paquet(EtatJoueur.normal(), m); + for (int n = 0; n < 2000 && expulsionTick < 0; n++) { + List 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