diff --git a/src/test/java/com/gastinelgarde/AutotestSuiviesTest.java b/src/test/java/com/gastinelgarde/AutotestSuiviesTest.java new file mode 100644 index 0000000..9f7980c --- /dev/null +++ b/src/test/java/com/gastinelgarde/AutotestSuiviesTest.java @@ -0,0 +1,64 @@ +package com.gastinelgarde; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.lang.reflect.Field; +import java.util.Map; +import net.minecraft.world.entity.Entity; +import net.minecraft.world.entity.EntityType; +import net.minecraft.world.entity.Marker; +import org.junit.jupiter.api.Assumptions; +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 à + * 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é + * « marker » construite sans monde. Si l'environnement de test ne permet pas de construire l'entité, le test est + * ignoré (assumption) au lieu d'échouer. + */ +class AutotestSuiviesTest { + + @SuppressWarnings("unchecked") + @Test + void FAILLE_revue3_tablePleineLesNouvellesCiblesNeSontJamaisSuivies() throws Exception { + Field fTable = Garde.class.getDeclaredField("SUIVIES"); + fTable.setAccessible(true); + Map table = (Map) fTable.get(null); + Field fMax = Garde.class.getDeclaredField("SUIVIES_MAX"); + fMax.setAccessible(true); + int max = fMax.getInt(null); + assertEquals(256, max); + + Entity cible; + try { + cible = new Marker(EntityType.MARKER, null); + } catch (Throwable t) { + Assumptions.abort("entité impossible à construire hors jeu : " + t); + return; + } + table.clear(); + try { + // Témoin : table vide, la cible frappée entre dans la table (mesurée au coup suivant). + assertNull(Garde.boitesVues(cible, null, 1000), "premier coup : historique incomplet"); + assertTrue(table.containsKey(cible.getId()), "témoin : la cible est suivie"); + + 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"); + } finally { + table.clear(); + } + } +} diff --git a/src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java b/src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java new file mode 100644 index 0000000..333618d --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/AutotestContournementsTest.java @@ -0,0 +1,259 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import java.util.UUID; +import org.junit.jupiter.api.BeforeEach; +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. + * Le contournement n°3 (table SUIVIES pleine) dépend de Minecraft : voir {@code com.gastinelgarde.AutotestSuiviesTest}. + */ +class AutotestContournementsTest { + + private static final double V = 0.28; // cible qui sprinte, blocs/tick + private GardeConfig cfg; + private Moteur moteur; + private final UUID joueur = UUID.randomUUID(); + + @BeforeEach + void init() { + cfg = new GardeConfig(); + moteur = new Moteur(cfg); + } + + private static double[] boite(double x) { + return new double[] {x - 0.3, 0, -0.3, x + 0.3, 1.8, 0.3}; + } + + /** Boîtes vues : cible qui avance de V par tick en x, arrivée en xNow (comme Garde92Test). */ + private static double[][] vues(double xNow, int fenetre) { + double[][] b = new double[fenetre + 2][]; + for (int i = 0; i < b.length; i++) b[i] = boite(xNow - V * (b.length - 1 - i)); + return b; + } + + private static double[] vers(double[] de, double x, double y, double z) { + return new double[] {x - de[0], y - de[1], z - de[2]}; + } + + private static double points(List vs, Controle c) { + double p = 0; + for (Verdict v : vs) if (v.controle() == c) p += v.points(); + return p; + } + + /** Coup mesuré par coups-hors-boite, puis paquet de mouvement suivant (œil et regard « suivants »). */ + private List coup(long t, EtatJoueur etat, double[] oeil, double[] regard, double[] oeilSuivant, + double[] regardSuivant, double xCible, double[][] vues) { + List vs = new ArrayList<>(moteur.coupDiffere(joueur, t, etat, oeil, regard, boite(xCible), 3.0, + V, true, false, oeil, vues)); + vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeilSuivant, regardSuivant)); + return vs; + } + + // --- Revue n°1 : ping gonflé au-delà de seriePingMaxMs = coup exempté ----------------------------------------- + + private double serieHitboxAvecPing(int ping) { + moteur = new Moteur(cfg); + EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build(); + int fenetre = PorteeHitbox.ticksFenetre(ping, cfg); + double total = 0; + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] oeil = {x, 1.62, -3.0}; + double[] regard = vers(oeil, x + 0.75, 1.2, 0); // client « hitbox » : 0,45 bloc devant la cible + total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)), + Controle.COUPS_HORS_BOITE); + } + return total; + } + + @Test + void FAILLE_revue1_pingDeclareAuDessusDe500msExempteTotalementLesCoups() { + 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é"); + } + + // --- Revue n°2 / C13 : regard et œil du paquet SUIVANT acceptés sans borne -------------------------------------- + + @Test + void FAILLE_revue2_regardSuivantRameneSurLaCibleEffaceLeCoupHorsBoite() { + int fenetre = PorteeHitbox.ticksFenetre(30, cfg); + double temoin = 0, triche = 0; + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] oeil = {x, 1.62, -3.0}; + double[] hors = {0, 0, -1}; // regard tourné à 180° de la cible au moment du coup + double[] surCible = vers(oeil, x, 1.2, 0); + triche += points(coup(k * 600L, EtatJoueur.normal(), oeil, hors, oeil, surCible, x, 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.0}; + double[] hors = {0, 0, -1}; + temoin += points(coup(k * 600L, EtatJoueur.normal(), oeil, hors, oeil, hors, x, vues(x, fenetre)), + 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)"); + } + + @Test + void FAILLE_revue2_oeilSuivantAvanceDe09BlocEffaceLaPorteeAllongee() { + int fenetre = PorteeHitbox.ticksFenetre(30, cfg); + double temoin = 0, triche = 0; + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] loin = {x, 1.62, -3.9}; // 3,6 blocs de la boîte : reach + double[] proche = {x, 1.62, -3.0}; // 0,9 bloc plus près au paquet suivant (sprint : 0,28 bloc/tick) + double[] regard = vers(loin, x, 1.2, 0); + triche += points(coup(k * 600L, EtatJoueur.normal(), loin, regard, proche, vers(proche, x, 1.2, 0), x, + vues(x, fenetre)), Controle.COUPS_HORS_BOITE); + } + moteur = new Moteur(cfg); + for (int k = 0; k < 10; k++) { + double x = 5 * k; + double[] loin = {x, 1.62, -3.9}; + double[] regard = vers(loin, x, 1.2, 0); + temoin += points(coup(k * 600L, EtatJoueur.normal(), loin, regard, loin, regard, x, vues(x, fenetre)), + 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"); + } + + @Test + void FAILLE_C13_porteeEtHitboxGardentLeMinimumAvecLePaquetSuivant() { + 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 + double[] proche = {0, 1.62, -3.5}; // 3,2 blocs au paquet suivant + double[] regard = vers(loin, 0, 1.0, 0); + // Témoin : paquet suivant identique. + List t = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0, + true, false)); + t.addAll(moteur.regardPorteeHitbox(joueur, 50, loin, regard)); + assertTrue(points(t, Controle.PORTEE) > 0, "témoin : 4,0 blocs sur cible immobile est vu"); + + moteur = new Moteur(cfg); + 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"); + + // Angle killaura : regard à 180° au coup, sur la cible au paquet suivant. + cfg.mode(Controle.PORTEE, Mode.OFF); + cfg.mode(Controle.HITBOX, Mode.OFF); + moteur = new Moteur(cfg); + double[] oeil = {0, 1.62, -2.5}; + 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"); + } + + @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"); + + 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"); + } + + // --- Revue n°4 : la fenêtre d'historique grandit avec le ping déclaré ------------------------------------------ + + private double serieDerriereLaCible(int ping) { + moteur = new Moteur(cfg); + EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build(); + int fenetre = PorteeHitbox.ticksFenetre(ping, cfg); // ce que Garde.boitesVues calcule depuis latency() + double total = 0; + for (int k = 0; k < 10; k++) { + double x = 10 * k; + double[] oeil = {x - 1.5, 1.62, -2.5}; + // Client « hitbox » : touche 3,3 blocs DERRIÈRE le centre de la cible (là où elle était il y a ~12 ticks). + double[] regard = vers(oeil, x - 3.6, 1.2, 0); + total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)), + Controle.COUPS_HORS_BOITE); + } + return total; + } + + @Test + void FAILLE_revue4_pingDeclareA450msElargitLaFenetreEtCacheLaTriche() { + 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)"); + } + + // --- C15 : vitesse 0,40 en l'air et Timer 1,09 non vus --------------------------------------------------------- + + private static EtatMouvement pas(double dxz, boolean sol) { + return new EtatMouvement(dxz, 0, 1, sol, sol, true, false, false, 0, 0, false, false); + } + + private double vitesse(double dxzAir, double dxzSol, int cycle, int ticks) { + cfg.mode(Controle.VOL, Mode.OFF); + cfg.mode(Controle.NO_FALL, Mode.OFF); + moteur = new Moteur(cfg); + double total = 0; + for (int i = 0; i < ticks; i++) { + boolean sol = cycle > 0 && i % cycle == 0; + total += points(moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), pas(sol ? dxzSol : dxzAir, sol)), + Controle.VITESSE); + } + return total; + } + + @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); + } + + @Test + void FAILLE_C15_speedAuSolA037BlocParTickNestJamaisVu() { + 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); + } + + private double timer(long intervalleMs, int secondes) { + moteur = new Moteur(cfg); + double total = 0; + for (long t = 0; t < secondes * 1000L; t += intervalleMs) { + total += points(moteur.paquetMouvement(joueur, 10_000 + t, EtatJoueur.normal()), Controle.TIMER); + } + return total; + } + + @Test + void FAILLE_C15_timerA109NestJamaisVu() { + 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"); + } +}