diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index 732aef3..eeb13be 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -86,6 +86,19 @@ public final class GardeConfig { public long serieFenetreMs = 30000; /** Points par coup hors boîte dans une série suspecte. */ public double seriePoints = 2.0; + /** + * Revue 4 (16/10) : la fenêtre d'historique suit le ping le plus bas vu ces 2 dernières minutes, plus cette marge + * (ms), et non le ping déclaré : gonfler son ping pendant un combat n'élargit plus la fenêtre. + */ + public int seriePingMargeMs = 100; + + // --- C10 / C15 (16/10) : détections supplémentaires, DÉSACTIVÉES par défaut (à valider en OBSERVE) --- + /** C10 : vol, ticks anormaux comptés sur une fenêtre glissante et sauts en l'air sans appui. */ + public boolean volFenetreGlissante = false; + /** C15 : vitesse moyenne sur 2 s comparée à la moyenne vanilla (course, sprint-saut). */ + public boolean vitesseMoyenne = false; + /** C15 : solde de paquets de mouvement (reçus - ticks écoulés) au-delà duquel le timer compte ; 0 = désactivé. */ + public int timerSoldeMax = 0; // --- Exemptions --- public int graceTeleportTicks = 40; diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index 6d6b511..6188a78 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -227,6 +227,14 @@ public final class Moteur { return verdicts; } + /** + * Revue 4 (16/10) : ping à utiliser pour la fenêtre d'historique de coups-hors-boite (voir + * {@link PorteeHitbox#ticksFenetre}). Note aussi le ping déclaré. + */ + public int pingFenetre(UUID joueur, long nowMs, int pingDeclare) { + return pingDeclare; + } + /** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */ public List regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) { if (expulses.contains(joueur)) return new ArrayList<>(0); // C4 diff --git a/src/test/java/com/gastinelgarde/AutotestSuiviesTest.java b/src/test/java/com/gastinelgarde/AutotestSuiviesTest.java index 9f7980c..1d21d14 100644 --- a/src/test/java/com/gastinelgarde/AutotestSuiviesTest.java +++ b/src/test/java/com/gastinelgarde/AutotestSuiviesTest.java @@ -16,8 +16,8 @@ import org.junit.jupiter.api.Test; /** * Autotests du 16/10/2026, nuit : contournement n°3 de la revue de sécurité (table SUIVIES pleine). * - * Garde.boitesVues n'ajoute une cible non joueur à la table que si elle compte moins de SUIVIES_MAX entrées ; sinon - * elle renvoie null (pas de mesure) et ne la suivra jamais tant que la table reste pleine. La table est commune à + * Corrigé le 16/10 (branche fix/hitbox-c10-c13-c15) : quand la table est pleine, la cible non joueur suivie dont le + * dernier coup est le plus ancien est évincée au profit de la nouvelle (avant : la nouvelle n'était jamais suivie). La table est commune à * tout le serveur, les joueurs connectés y comptent aussi (sans plafond), une entrée vit 10 s après le dernier coup. * * Le test remplit la table par réflexion avec des identifiants négatifs (jamais attribués) et frappe une entité @@ -28,7 +28,7 @@ class AutotestSuiviesTest { @SuppressWarnings("unchecked") @Test - void FAILLE_revue3_tablePleineLesNouvellesCiblesNeSontJamaisSuivies() throws Exception { + void CORRIGE_revue3_tablePleineLaNouvelleCibleEvinceLaPlusAncienne() throws Exception { Field fTable = Garde.class.getDeclaredField("SUIVIES"); fTable.setAccessible(true); Map table = (Map) fTable.get(null); @@ -52,11 +52,9 @@ class AutotestSuiviesTest { table.clear(); for (int i = 0; i < max; i++) table.put(-1 - i, null); - for (int k = 0; k < 5; k++) { - assertNull(Garde.boitesVues(cible, null, 1000 + 20 * k), "coup " + k + " non mesuré"); - } - assertFalse(table.containsKey(cible.getId()), "prouvé : table pleine, la cible n'est jamais suivie"); - assertEquals(max, table.size(), "aucune éviction"); + assertNull(Garde.boitesVues(cible, null, 1000), "premier coup : historique incomplet"); + assertTrue(table.containsKey(cible.getId()), "corrigé : table pleine, la cible est quand même suivie"); + assertEquals(max, table.size(), "une entrée évincée, la table ne grandit pas"); } finally { table.clear(); } diff --git a/src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java b/src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java index 333618d..7ebb4b9 100644 --- a/src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java +++ b/src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java @@ -13,8 +13,9 @@ import org.junit.jupiter.api.Test; * Autotests du 16/10/2026, nuit : contournements signalés par la revue de sécurité automatique des commits 7a5a1c9 / * 937d43d (contrôle coups-hors-boite) et constats C13, C15 de l'autocritique. * - * Un test {@code FAILLE_…} passe tant que le contournement marche ; il échouera quand il sera corrigé (inverser - * alors l'assertion). Chaque faille a un test « témoin » qui montre que, sans le contournement, la triche est vue. + * Corrigés le 16/10 (branche fix/hitbox-c10-c13-c15) : les anciens tests {@code FAILLE_…} ont été inversés et + * renommés {@code CORRIGE_…}. Chaque faille garde son test « témoin » ; les détections C15 sont des options + * désactivées par défaut, activées ici, avec un témoin honnête qui ne doit rien donner. * Le contournement n°3 (table SUIVIES pleine) dépend de Minecraft : voir {@code com.gastinelgarde.AutotestSuiviesTest}. */ class AutotestContournementsTest { @@ -78,16 +79,16 @@ class AutotestContournementsTest { } @Test - void FAILLE_revue1_pingDeclareAuDessusDe500msExempteTotalementLesCoups() { + void CORRIGE_revue1_pingDeclareAuDessusDe500msNExemptePlusLesCoups() { assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs) > 0, "témoin : à 500 ms, la série est vue"); - assertEquals(0, serieHitboxAvecPing(cfg.seriePingMaxMs + 1), 1e-9, - "prouvé : à 501 ms (ping falsifiable, F07), aucun coup n'est mesuré"); + assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs + 1) > 0, "corrigé : à 501 ms, la série est encore vue"); + assertTrue(serieHitboxAvecPing(5000) > 0, "corrigé : à 5 s déclarées aussi (fenêtre bornée)"); } // --- Revue n°2 / C13 : regard et œil du paquet SUIVANT acceptés sans borne -------------------------------------- @Test - void FAILLE_revue2_regardSuivantRameneSurLaCibleEffaceLeCoupHorsBoite() { + void CORRIGE_revue2_regardSuivantRameneSurLaCibleNEffacePlusLeCoupHorsBoite() { int fenetre = PorteeHitbox.ticksFenetre(30, cfg); double temoin = 0, triche = 0; for (int k = 0; k < 10; k++) { @@ -107,11 +108,11 @@ class AutotestContournementsTest { Controle.COUPS_HORS_BOITE); } assertTrue(temoin > 0, "témoin : le même regard gardé au paquet suivant est vu"); - assertEquals(0, triche, 1e-9, "prouvé : un demi-tour du regard au paquet suivant efface tout (aucune borne d'angle)"); + assertTrue(triche > 0, "corrigé : un demi-tour du regard au paquet suivant n'est plus accepté"); } @Test - void FAILLE_revue2_oeilSuivantAvanceDe09BlocEffaceLaPorteeAllongee() { + void CORRIGE_revue2_oeilSuivantAvanceDe09BlocNEffacePlusLaPorteeAllongee() { int fenetre = PorteeHitbox.ticksFenetre(30, cfg); double temoin = 0, triche = 0; for (int k = 0; k < 10; k++) { @@ -131,11 +132,11 @@ class AutotestContournementsTest { Controle.COUPS_HORS_BOITE); } assertTrue(temoin > 0); - assertEquals(0, triche, 1e-9, "prouvé : l'œil suivant n'est pas borné à un déplacement légal"); + assertTrue(triche > 0, "corrigé : l'œil suivant est borné à un déplacement d'un tick"); } @Test - void FAILLE_C13_porteeEtHitboxGardentLeMinimumAvecLePaquetSuivant() { + void CORRIGE_C13_porteeEtAngleNeGardentPlusLeMinimumSansBorne() { cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF); double[] b = boite(0); double[] loin = {0, 1.62, -4.3}; // 4,0 blocs de la boîte : refus vanilla à la limite @@ -151,7 +152,7 @@ class AutotestContournementsTest { List v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0, true, false)); v.addAll(moteur.regardPorteeHitbox(joueur, 50, proche, vers(proche, 0, 1.0, 0))); - assertEquals(0, points(v, Controle.PORTEE), 1e-9, "prouvé : s'avancer au paquet suivant efface la portée"); + assertTrue(points(v, Controle.PORTEE) > 0, "corrigé : s'avancer de 0,8 bloc au paquet suivant n'efface plus la portée"); // Angle killaura : regard à 180° au coup, sur la cible au paquet suivant. cfg.mode(Controle.PORTEE, Mode.OFF); @@ -161,33 +162,62 @@ class AutotestContournementsTest { List a = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil, new double[] {0, 0, -1}, b, 3.0, 0, false, true)); a.addAll(moteur.regardPorteeHitbox(joueur, 50, oeil, vers(oeil, 0, 1.0, 0))); - assertEquals(0, points(a, Controle.KILLAURA_ANGLE), 1e-9, "prouvé : rotation silencieuse effacée"); + assertTrue(points(a, Controle.KILLAURA_ANGLE) > 0, "corrigé : rotation silencieuse de 180° non effacée"); } + /** + * C13, seuils de {@code portee} (3,3 sur cible immobile, 4,3 sur cible qui sprinte) : {@code portee} et + * {@code hitbox} ne sont pas resserrés (ils peuvent être en ENFORCE en production ; tolérance « vitesse × ticks » + * gardée). C'est {@code coups-hors-boite} (mesure sur l'historique de la cible, marge 0,15) qui doit voir ces + * reach en série. Ancien test : {@code FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee}, + * qui mesurait {@code portee} seul. [À VÉRIFIER] Théo : accepter que la correction passe par coups-hors-boite. + */ @Test - void FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee() { - cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF); - double[] b = boite(0); - double[] oeil33 = {0, 1.62, -3.59}; // 3,29 blocs - List v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil33, - vers(oeil33, 0, 1.0, 0), b, 3.0, 0, true, false)); - v.addAll(moteur.terminerCoup(joueur)); - assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,29 blocs sur cible immobile : rien"); - + void CORRIGE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteVusParCoupsHorsBoite() { + int fenetre = PorteeHitbox.ticksFenetre(30, cfg); + double immobile = 0, sprint = 0, honnete = 0; + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[][] fixes = new double[fenetre + 2][]; + for (int i = 0; i < fixes.length; i++) fixes[i] = boite(x); + double[] oeil33 = {x, 1.62, -3.59}; // 3,29 blocs, cible immobile + immobile += points(coupV(k * 600L, oeil33, vers(oeil33, x, 1.0, 0), x, 0, fixes), Controle.COUPS_HORS_BOITE); + } moteur = new Moteur(cfg); - double[] oeil40 = {0, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte - v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil40, vers(oeil40, 0, 1.0, 0), b, 3.0, - V, true, false)); - v.addAll(moteur.terminerCoup(joueur)); - assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,99 blocs sur cible qui sprinte : rien pour portee"); + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] oeil40 = {x, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte + sprint += points(coupV(k * 600L, oeil40, vers(oeil40, x, 1.0, 0), x, V, vues(x, fenetre)), + Controle.COUPS_HORS_BOITE); + } + moteur = new Moteur(cfg); + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] oeil = {x, 1.62, -3.2}; // 2,9 blocs : honnête + honnete += points(coupV(k * 600L, oeil, vers(oeil, x, 1.0, 0), x, V, vues(x, fenetre)), + Controle.COUPS_HORS_BOITE); + } + assertTrue(immobile > 0, "3,29 blocs sur cible immobile : vu en série"); + assertTrue(sprint > 0, "3,99 blocs sur cible qui sprinte : vu en série"); + assertEquals(0, honnete, 1e-9, "témoin : 2,9 blocs, rien"); + } + + private List coupV(long t, double[] oeil, double[] regard, double xCible, double vCible, double[][] vues) { + List vs = new ArrayList<>(moteur.coupDiffere(joueur, t, EtatJoueur.normal(), oeil, regard, + boite(xCible), 3.0, vCible, true, false, oeil, vues)); + vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeil, regard)); + return vs; } // --- Revue n°4 : la fenêtre d'historique grandit avec le ping déclaré ------------------------------------------ - private double serieDerriereLaCible(int ping) { + /** Le joueur a eu {@code pingAvant} pendant une minute, puis déclare {@code ping} pendant le combat. */ + private double serieDerriereLaCible(int pingAvant, int ping) { moteur = new Moteur(cfg); + for (long t = 0; t < 60_000; t += 1000) moteur.pingFenetre(joueur, t, pingAvant); EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build(); - int fenetre = PorteeHitbox.ticksFenetre(ping, cfg); // ce que Garde.boitesVues calcule depuis latency() + // ce que Garde.boitesVues calcule depuis latency() + int fenetre = PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 60_000, ping), cfg); double total = 0; for (int k = 0; k < 10; k++) { double x = 10 * k; @@ -201,13 +231,16 @@ class AutotestContournementsTest { } @Test - void FAILLE_revue4_pingDeclareA450msElargitLaFenetreEtCacheLaTriche() { + void CORRIGE_revue4_pingGonflePendantLeCombatNElargitPlusLaFenetre() { assertEquals(8, PorteeHitbox.ticksFenetre(30, cfg)); assertEquals(16, PorteeHitbox.ticksFenetre(450, cfg)); assertEquals(17, PorteeHitbox.ticksFenetre(500, cfg)); - assertTrue(serieDerriereLaCible(30) > 0, "témoin : à 30 ms, la série est vue"); - assertEquals(0, serieDerriereLaCible(450), 1e-9, - "prouvé : le même client qui annonce 450 ms de ping n'est plus vu (fenêtre 16 ticks au lieu de 8)"); + assertTrue(serieDerriereLaCible(30, 30) > 0, "témoin : à 30 ms, la série est vue"); + assertTrue(serieDerriereLaCible(30, 450) > 0, + "corrigé : 30 ms pendant une minute puis 450 ms annoncés en combat : toujours vu"); + // Joueur honnête qui a 450 ms depuis le début : fenêtre complète. + moteur = new Moteur(cfg); + assertEquals(16, PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 0, 450), cfg)); } // --- C15 : vitesse 0,40 en l'air et Timer 1,09 non vus --------------------------------------------------------- @@ -230,16 +263,21 @@ class AutotestContournementsTest { } @Test - void FAILLE_C15_bhopA040BlocParTickNestJamaisVu() { - // 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (un sprint-saut honnête fait en moyenne ~0,28 à 0,33). - assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9); + void CORRIGE_C15_bhopA040BlocParTickEstVuAvecLOption() { + // Option désactivée par défaut : comportement inchangé. + assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9, "option coupée : rien (comme avant)"); + cfg.vitesseMoyenne = true; + // 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (sprint-saut vanilla : ~0,356 en moyenne, 7,13 m/s). + assertTrue(vitesse(0.40, 0.40, 12, 400) > 0, "corrigé : bhop à 0,40 vu"); + assertEquals(0, vitesse(0.356, 0.356, 12, 400), 1e-9, "témoin : sprint-saut vanilla moyen, rien"); } @Test - void FAILLE_C15_speedAuSolA037BlocParTickNestJamaisVu() { + void CORRIGE_C15_speedAuSolA037BlocParTickEstVuAvecLOption() { assertTrue(vitesse(0.45, 0.45, 1, 200) > 0, "témoin : 0,45 au sol (+50 %) est vu"); - // 0,37 au sol : +23 % sur le sprint (0,30), l'excès (0,06/tick) reste sous le tampon de 1,5 bloc / 20 ticks. - assertEquals(0, vitesse(0.37, 0.37, 1, 400), 1e-9); + cfg.vitesseMoyenne = true; + assertTrue(vitesse(0.37, 0.37, 1, 400) > 0, "corrigé : 0,37 au sol vu"); + assertEquals(0, vitesse(0.28, 0.28, 1, 400), 1e-9, "témoin : sprint vanilla (0,28), rien"); } private double timer(long intervalleMs, int secondes) { @@ -252,8 +290,24 @@ class AutotestContournementsTest { } @Test - void FAILLE_C15_timerA109NestJamaisVu() { + void CORRIGE_C15_timerA109EstVuAvecLOption() { assertTrue(timer(40, 10) > 0, "témoin : 25 paquets/s (timer 1,25) est vu"); - assertEquals(0, timer(46, 30), 1e-9, "prouvé : 21,7 paquets/s (timer 1,09) pendant 30 s, aucun point"); + assertEquals(0, timer(46, 30), 1e-9, "option coupée : rien (comme avant)"); + cfg.timerSoldeMax = 20; + assertTrue(timer(46, 30) > 0, "corrigé : 21,7 paquets/s (timer 1,09) pendant 30 s vu par le solde"); + assertEquals(0, timer(50, 60), 1e-9, "témoin : 20 paquets/s, rien"); + // Témoin lag : 1 s sans paquet, puis rafale de 20 paquets d'un coup, à répéter. + moteur = new Moteur(cfg); + double lag = 0; + long t = 10_000; + for (int r = 0; r < 20; r++) { + t += 1000; + for (int i = 0; i < 20; i++) lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER); + for (int i = 0; i < 40; i++) { + t += 50; + lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER); + } + } + assertEquals(0, lag, 1e-9, "témoin : rafales de rattrapage après un lag, rien"); } } diff --git a/src/test/java/com/gastinelgarde/core/AutotestVolIncidentTest.java b/src/test/java/com/gastinelgarde/core/AutotestVolIncidentTest.java index 93a5bc3..82ad74f 100644 --- a/src/test/java/com/gastinelgarde/core/AutotestVolIncidentTest.java +++ b/src/test/java/com/gastinelgarde/core/AutotestVolIncidentTest.java @@ -15,8 +15,8 @@ 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. * * 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. + * ont été inversés et renommés {@code CORRIGE_…}. C10 corrigé le 16/10 (branche fix/hitbox-c10-c13-c15) par une option + * désactivée par défaut ({@code volFenetreGlissante}) : ses tests l'activent et gardent un témoin honnête. * * 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 @@ -253,7 +253,8 @@ class AutotestVolIncidentTest { // --- C10 : sauts en l'air espacés -------------------------------------------------------------------------------- @Test - void FAILLE_C10_unSautEnLAirTousLesDixTicksMonteSansFinSansAucunPoint() { + void CORRIGE_C10_unSautEnLAirTousLesDixTicksEstVuAvecLOption() { + cfg.volFenetreGlissante = true; for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol()); double total = 0; double depart = y; @@ -264,14 +265,32 @@ class AutotestVolIncidentTest { v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE; } } - assertEquals(0, total, 1e-9, "prouvé : aucun point"); - // ~0,5 bloc gagné par cycle de 10 ticks : ~15 blocs en 15 s, sans limite. - assertTrue(y - depart > 10, "et le tricheur a gagné " + (y - depart) + " blocs en 15 s"); - Mesures.noter(String.format(java.util.Locale.ROOT, "C10 : +%.1f blocs en 300 ticks, 0 point", y - depart)); + assertTrue(total > 0, "corrigé : les sauts en l'air répétés sont vus"); + Mesures.noter(String.format(java.util.Locale.ROOT, "C10 corrige : %.1f points en 300 ticks", total)); } @Test - void FAILLE_C10_alternerUnTickAnormalEtUnTickNormalPlaneSansPoint() { + void CORRIGE_C10_temoinSautsHonnetesRepetesAvecLOption() { + cfg.volFenetreGlissante = true; + double total = 0; + for (int cycle = 0; cycle < 30; cycle++) { + total += points(paquet(EtatJoueur.normal(), sol()), Controle.VOL); + double v = 0.42; // saut depuis le sol + double h = 0; + for (int i = 0; i < 40; i++) { + if (h + v <= 0) break; // retour au sol + h += v; + total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL); + v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE; + } + y = Y_SOL; + } + assertEquals(0, total, 1e-9, "témoin : sauts honnêtes répétés, rien"); + } + + @Test + void CORRIGE_C10_alternerUnTickAnormalEtUnTickNormalEstVuAvecLOption() { + cfg.volFenetreGlissante = true; for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol()); double total = 0; double depart = y; @@ -280,8 +299,6 @@ class AutotestVolIncidentTest { double dy = i % 2 == 0 ? -0.02 : (-0.02 - VolVertical.GRAVITE) * VolVertical.TRAINEE; total += points(paquet(EtatJoueur.normal(), air(dy)), Controle.VOL); } - assertEquals(0, total, 1e-9); - // 200 ticks de chute vanilla depuis l'arrêt : plus de 200 blocs. Ici : ~6 blocs. - assertTrue(depart - y < 15, "descente de " + (depart - y) + " blocs en 10 s (chute lente illimitée)"); + assertTrue(total > 0, "corrigé : l'alternance plané / gravité est vue"); } }