GastinelGarde : tests revue 1-4, C10, C13, C15 inverses (CORRIGE_...), rouges avant correctif

Tests FAILLE_ inverses en CORRIGE_ ; temoins honnetes ajoutes pour C10, C15.
Stubs sans effet pour compiler : options C10/C15 (desactivees), Moteur.pingFenetre.
cornafserver (conteneur jetable) : 254 tests, 11 echecs attendus.
Le test C13 seuils passe deja : reecrit pour verifier coups-hors-boite (a valider).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Opus 5.5 a révisé 2026-10-16 06:05:45 +02:00
1 Parent d9530d0661
révision 080415c646
5 fichiers modifiés
+149 -59

Aucun fichier ne correspond à votre recherche

+13
Voir le fichier
@@ -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;
+8
Voir le fichier
@@ -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<Verdict> regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
+6 -8
Voir le fichier
@@ -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<Integer, Object> table = (Map<Integer, Object>) 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();
}
+94 -40
Voir le fichier
@@ -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<Verdict> 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<Verdict> 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<Verdict> 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<Verdict> coupV(long t, double[] oeil, double[] regard, double xCible, double vCible, double[][] vues) {
List<Verdict> 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");
}
}
+28 -11
Voir le fichier
@@ -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");
}
}