From 44504eca0c298a0142c393e680200032085c60ac Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Fri, 16 Oct 2026 01:10:46 +0200 Subject: [PATCH] GastinelGarde autotests : cas limites d'un joueur honnete 22 tests : fins d'elytres, bords de blocs, plafond, echelles, eau, slime, miel, montures et bateaux, teleportations, Create / Aeronautics, riptide, lag. Faux positifs documentes : plane d'elytres puni aussi par vitesse, miel ou vaisseau non detectes, client fige apres la grace de teleportation, chute recue en rafales de 3 paquets (gigue reseau). Code de production inchange. 250 tests, 0 echec (cornafserver, conteneur eclipse-temurin:21-jdk). Co-Authored-By: Claude Opus 5.5 --- .../core/AutotestCasLimitesTest.java | 363 ++++++++++++++++++ 1 file changed, 363 insertions(+) create mode 100644 src/test/java/com/gastinelgarde/core/AutotestCasLimitesTest.java diff --git a/src/test/java/com/gastinelgarde/core/AutotestCasLimitesTest.java b/src/test/java/com/gastinelgarde/core/AutotestCasLimitesTest.java new file mode 100644 index 0000000..c7bffc5 --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/AutotestCasLimitesTest.java @@ -0,0 +1,363 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +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 : cas limites d'un joueur HONNÊTE (fins d'élytres, bords de blocs, échelles, eau, + * slime, miel, montures, téléportations, Create / Aeronautics, riptide, lag). + * + * Un test {@code honnete_…} vérifie qu'aucun point n'est donné. Un test {@code FAUX_POSITIF_…} montre un cas honnête + * (ou plausible, à confirmer en jeu) qui est puni aujourd'hui : il passe tant que le défaut existe. + * + * Les drapeaux « milieu spécial », « au sol serveur », exemptions… sont calculés par l'adaptateur (Garde.java) à partir + * du monde : ici on suppose qu'il les calcule bien. Ce qui dépend de la détection elle-même (bloc de miel trouvé, + * contraption vue) n'est pas testable hors jeu. + */ +class AutotestCasLimitesTest { + + private GardeConfig cfg; + private Moteur moteur; + private final UUID joueur = UUID.randomUUID(); + private long tick; + + @BeforeEach + void init() { + cfg = new GardeConfig(); + cfg.mode(Controle.VOL, Mode.ENFORCE); + cfg.mode(Controle.VITESSE, Mode.OFF); + cfg.mode(Controle.NO_FALL, Mode.OBSERVE); + moteur = new Moteur(cfg); + tick = 5000; + } + + private static EtatMouvement m(double dxz, double dy, int ticks, boolean sol, boolean milieu) { + return new EtatMouvement(dxz, dy, ticks, sol, sol, false, false, false, 0, 0, milieu, false); + } + + private static EtatMouvement air(double dy) { + return m(0.1, dy, 1, false, false); + } + + private static EtatMouvement sol() { + return m(0.1, 0, 1, true, false); + } + + private static double points(List vs, Controle c) { + double p = 0; + for (Verdict v : vs) if (v.controle() == c) p += v.points(); + return p; + } + + private double paquet(EtatJoueur e, EtatMouvement mv) { + tick += Math.max(1, mv.ticks()); + List vs = moteur.mouvement(joueur, tick * 50L, e, mv); + return points(vs, Controle.VOL) + points(vs, Controle.NO_FALL) + points(vs, Controle.VITESSE); + } + + /** Chute vanilla depuis la vitesse v, n ticks. */ + private double chute(EtatJoueur e, double v, int n) { + double total = 0; + for (int i = 0; i < n; i++) { + total += paquet(e, air(v)); + v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE; + } + return total; + } + + private void auSol(int n) { + for (int i = 0; i < n; i++) paquet(EtatJoueur.normal(), sol()); + } + + // --- Élytres ----------------------------------------------------------------------------------------------------- + + @Test + void honnete_atterrissageEnElytresPuisMarche() { + auSol(3); + EtatJoueur el = EtatJoueur.builder().elytres(true).build(); + double total = 0; + for (int i = 0; i < 100; i++) total += paquet(el, m(1.2, -0.4, 1, false, false)); + total += paquet(el, m(0.8, -0.3, 1, true, false)); // touche le sol, drapeau encore là + for (int i = 0; i < 20; i++) total += paquet(EtatJoueur.normal(), sol()); + assertEquals(0, total, 1e-9); + } + + @Test + void honnete_finDElytresVitesseHorizontaleQuiDecroit() { + cfg.mode(Controle.VITESSE, Mode.OBSERVE); + auSol(3); + EtatJoueur el = EtatJoueur.builder().elytres(true).build(); + for (int i = 0; i < 40; i++) paquet(el, m(1.5, -0.3, 1, false, false)); + double total = 0, dxz = 1.5, v = -0.3; + for (int i = 0; i < 40; i++) { // drapeau tombé, le joueur tombe vraiment : traînée 0,91 et gravité + dxz *= VitesseHorizontale.TRAINEE_AIR; + total += paquet(EtatJoueur.normal(), m(dxz, v, 1, false, false)); + v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE; + } + assertEquals(0, total, 1e-9); + } + + @Test + void FAUX_POSITIF_finDElytresPlaneQuiContinueCoteClientPuniAussiParVitesse() { + cfg.mode(Controle.VOL, Mode.OFF); + cfg.mode(Controle.VITESSE, Mode.OBSERVE); + auSol(3); + EtatJoueur el = EtatJoueur.builder().elytres(true).build(); + for (int i = 0; i < 40; i++) paquet(el, m(1.0, -0.1, 1, false, false)); + double total = 0; + for (int i = 0; i < 20; i++) total += paquet(EtatJoueur.normal(), m(1.0, -0.1, 1, false, false)); + // Même famille que C1 et que l'alerte vitesse de totoche10 du 15/10 : l'élan hérité ne couvre que 3 ticks. + assertTrue(total > 0, "plané continu après la chute du drapeau : puni par vitesse"); + } + + // --- Bords de blocs ---------------------------------------------------------------------------------------------- + + @Test + void honnete_glissadeAuBordDUnBlocLaTrancheBalayeeTrouveLeBloc() { + // Bloc plein x dans [9 ; 10]. Avant : boîte [9,5 ; 10,1] (sur le bloc). Après un pas de 0,6 : [10,1 ; 10,7]. + double[] t = NoFall.trancheBalayee(10.1, 64.0, 0.2, 10.7, 0.8, 0.6, 0); + assertTrue(t[0] < 10.0 && t[3] > 9.0, "la tranche couvre encore le bloc"); + assertEquals(63.95, t[1], 1e-9); + // Avec le bloc trouvé, « au sol serveur » est vrai : aucun point no-fall. + assertEquals(0, NoFall.points(m(0.6, -0.5, 1, true, true)), 1e-9); + // Sans la tranche (ancien calcul), le même paquet donnait 0,5 point. + assertEquals(0.5, NoFall.points(new EtatMouvement(0.6, -0.5, 1, true, false, false, false, false, 0, 0, + false, false)), 1e-9); + } + + @Test + void honnete_tomberDUnBordEtSautSousUnPlafond() { + auSol(3); + double total = chute(EtatJoueur.normal(), -0.0784, 30); // marche au-delà du bord + auSol(3); + // Saut sous un plafond à 1,25 bloc : +0,42, puis tête cognée (vitesse remise à 0), puis gravité. + total += paquet(EtatJoueur.normal(), air(0.42)); + total += paquet(EtatJoueur.normal(), air(0.05)); + total += chute(EtatJoueur.normal(), (0 - VolVertical.GRAVITE) * VolVertical.TRAINEE, 6); + auSol(3); + assertEquals(0, total, 1e-9); + } + + // --- Échelles, eau, slime, miel ------------------------------------------------------------------------------ + + @Test + void honnete_echelleMonteeArretAccroupiEtSortieEnHaut() { + auSol(3); + double total = 0; + for (int i = 0; i < 40; i++) total += paquet(EtatJoueur.normal(), m(0, 0.2, 1, false, true)); + for (int i = 0; i < 40; i++) total += paquet(EtatJoueur.normal(), m(0, 0, 1, false, true)); // accroupi + total += chute(EtatJoueur.normal(), (0.2 - VolVertical.GRAVITE) * VolVertical.TRAINEE, 15); // lâche en haut + auSol(3); + assertEquals(0, total, 1e-9); + } + + @Test + void honnete_nageEtSortieDeLEauAvecImpulsion() { + auSol(3); + double total = 0; + for (int i = 0; i < 40; i++) total += paquet(EtatJoueur.normal(), m(0.1, 0.1, 1, false, true)); + // Sortie : impulsion de 0,3 (jumpOutOfFluid) au tick où l'eau n'est plus vue [À VÉRIFIER en jeu]. + total += chute(EtatJoueur.normal(), 0.3, 20); + assertEquals(0, total, 1e-9); + } + + @Test + void honnete_rebondsSurSlime() { + auSol(3); + double total = chute(EtatJoueur.normal(), -0.0784, 25); // chute de ~10 blocs + double v = 1.0; + for (int r = 0; r < 4; r++) { + total += paquet(EtatJoueur.normal(), m(0.1, 0, 1, true, true)); // contact slime + total += chute(EtatJoueur.normal(), v, 30); + v *= 0.8; + } + assertEquals(0, total, 1e-9); + } + + @Test + void honnete_glissadeLeLongDUnBlocDeMielPuisChute() { + auSol(3); + double total = chute(EtatJoueur.normal(), 0.42, 3); + for (int i = 0; i < 80; i++) total += paquet(EtatJoueur.normal(), m(0, -0.05, 1, false, true)); + total += chute(EtatJoueur.normal(), (-0.05 - VolVertical.GRAVITE) * VolVertical.TRAINEE, 10); + assertEquals(0, total, 1e-9); + } + + @Test + void FAUX_POSITIF_mielNonDetecteLaGlissadeEstPriseCommeUnPlane() { + // Si l'adaptateur ne voit pas le miel (bloc à plus de 0,1 bloc de la boîte, bloc de mod collant…), la descente + // à -0,05 bloc/tick est un plané : la détection elle-même n'est pas testable hors jeu. + auSol(3); + double total = chute(EtatJoueur.normal(), 0.42, 3); + for (int i = 0; i < 30; i++) total += paquet(EtatJoueur.normal(), air(-0.05)); + assertTrue(total > 0); + } + + // --- Montures et véhicules ------------------------------------------------------------------------------------- + + @Test + void honnete_descendreDeChevalEnPleinSaut() { + auSol(3); + EtatJoueur monte = EtatJoueur.builder().enVehicule(true).build(); + double total = 0; + for (int i = 0; i < 10; i++) total += paquet(monte, air(0.3)); + total += chute(EtatJoueur.normal(), 0.1, 25); + assertEquals(0, total, 1e-9); + } + + @Test + void honnete_sautDeChevalEtBateauQuiTombeDUneFalaise() { + UUID j = UUID.randomUUID(); + double total = 0; + double v = 0.9; + for (int i = 0; i < 30; i++) { // saut de cheval (force 0,9) : ~25 ticks en l'air + EtatVehicule e = new EtatVehicule(EtatVehicule.Type.MONTURE, 0.5, v, 1, false, false, false, 0.3, false); + total += points(moteur.vehicule(j, (100 + i) * 50L, EtatJoueur.normal(), e), Controle.VEHICULE_VOL); + v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE; + } + moteur.nouveauVehicule(j); + v = 0; + for (int i = 0; i < 80; i++) { // bateau : -0,04 par tick, sans traînée verticale + v -= 0.04; + EtatVehicule e = new EtatVehicule(EtatVehicule.Type.BATEAU, 0.3, v, 1, false, false, false, 0, false); + total += points(moteur.vehicule(j, (200 + i) * 50L, EtatJoueur.normal(), e), Controle.VEHICULE_VOL); + } + assertEquals(0, total, 1e-9); + } + + // --- Téléportations ---------------------------------------------------------------------------------------------- + + @Test + void honnete_teleportationEnLAirPuisChute() { + auSol(3); + double total = 0; + for (int t = 0; t <= cfg.graceTeleportTicks; t++) { + total += paquet(EtatJoueur.builder().ticksDepuisTeleport(t).build(), air(-0.0784 * Math.min(t, 5))); + } + total += chute(EtatJoueur.normal(), -0.5, 40); + assertEquals(0, total, 1e-9); + } + + @Test + void FAUX_POSITIF_teleportationLenteLeJoueurResteFigeApresLaGrace() { + // /rtp, /tpa vers des tronçons non chargés : si le client reste figé (dy = 0) plus de 2 s après la + // téléportation, la grâce (40 ticks) est finie et l'immobilité en l'air est un plané [À VÉRIFIER en jeu]. + auSol(3); + double total = 0; + for (int t = 0; t <= cfg.graceTeleportTicks; t++) { + total += paquet(EtatJoueur.builder().ticksDepuisTeleport(t).build(), air(0)); + } + assertEquals(0, total, 1e-9, "pendant la grâce : rien"); + for (int i = 0; i < 20; i++) total += paquet(EtatJoueur.normal(), air(0)); + assertTrue(total > 0, "figé 1 s de plus après la grâce : puni"); + } + + @Test + void FAUX_POSITIF_C2_reapparitionPendantUnSetbackNonOuverte() { + // Rappel : GraceTeleport n'ouvre pas de grâce pour SETBACK ni pour un renvoi de SETBACK. + GraceTeleport g = new GraceTeleport(); + g.annoncer(GraceTeleport.Origine.SETBACK); + assertFalse(g.teleport()); + g.annoncer(GraceTeleport.Origine.RENVOI); + assertFalse(g.teleport(), "renvoi d'un setback non confirmé : pas de grâce non plus"); + assertTrue(g.teleport(), "une téléportation externe ouvre la grâce"); + } + + // --- Create / Aeronautics ------------------------------------------------------------------------------------- + + @Test + void honnete_surUnVaisseauQuiMontePuisSautEnBas() { + auSol(3); + EtatJoueur poche = EtatJoueur.builder().pocheContraption(true).build(); + double total = 0; + for (int i = 0; i < 200; i++) total += paquet(poche, air(0.1)); // le pont monte, le serveur n'y voit pas de sol + total += chute(EtatJoueur.normal(), 0.1, 40); + assertEquals(0, total, 1e-9); + assertTrue(DetectionContraption.dansLaGrace(140, 100, 40)); + assertFalse(DetectionContraption.dansLaGrace(141, 100, 40)); + assertFalse(DetectionContraption.dansLaGrace(90, 100, 40), "horloge revenue en arrière : pas de grâce"); + // Véhicule de mod (dirigeable, train Create) : jamais contrôlé en vol. + EtatVehicule dirigeable = new EtatVehicule(EtatVehicule.Type.AUTRE, 0.5, 0.0, 1, false, false, false, 0, false); + for (int i = 0; i < 100; i++) { + assertEquals(0, points(moteur.vehicule(joueur, (9000 + i) * 50L, EtatJoueur.normal(), dirigeable), + Controle.VEHICULE_VOL), 1e-9); + } + } + + @Test + void FAUX_POSITIF_vaisseauNonDetecteLeJoueurSurLePontEstPrisPourUnVoleur() { + // Dépendance totale à la détection (DetectionContraption / SableAcces), non testable hors jeu : si le pont + // d'un grand vaisseau n'est pas vu (distanceContraption trop courte, classe de mod inconnue), punition. + auSol(3); + double total = 0; + for (int i = 0; i < 30; i++) total += paquet(EtatJoueur.normal(), air(0.1)); + assertTrue(total > 0); + } + + // --- Riptide ------------------------------------------------------------------------------------------------- + + @Test + void honnete_vrilleRiptidePuisArcBalistique() { + auSol(3); + EtatJoueur vrille = EtatJoueur.builder().riptide(true).build(); + double total = 0; + for (int i = 0; i < 20; i++) total += paquet(vrille, m(2.5, 1.5, 1, false, false)); + total += chute(EtatJoueur.normal(), 1.2, 60); + assertEquals(0, total, 1e-9); + } + + // --- Lag --------------------------------------------------------------------------------------------------------- + + /** + * Longue chute (80 paquets, un tick client chacun) reçue avec une gigue réseau régulière : {@code motif} donne + * les ticks serveur écoulés avant chaque paquet (ex. 3, 0, 0 : trois paquets arrivés ensemble toutes les 3 ticks). + */ + private double chuteAvecGigue(int[] motif) { + auSol(3); + double total = 0, v = 0; + for (int p = 0; p < 80; p++) { + total += paquet(EtatJoueur.normal(), m(0.1, v, motif[p % motif.length], false, false)); + v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE; + } + return total; + } + + @Test + void honnete_lagRafalesDeDeuxEtDeCinqPaquets() { + assertEquals(0, chuteAvecGigue(new int[] {2, 0}), 1e-9); + assertEquals(0, chuteAvecGigue(new int[] {5, 0, 0, 0, 0}), 1e-9); + assertEquals(0, chuteAvecGigue(new int[] {4, 0, 0, 0}), 1e-9); + } + + @Test + void FAUX_POSITIF_lagRafalesDeTroisPaquetsPendantUneLongueChute() { + // Un paquet d'UN tick client arrivé après 3 ticks serveur n'est comparé qu'à 2 ou 3 ticks de gravité, et la + // vitesse retenue est alors dy / 3 : le paquet suivant est faux aussi. Motif 3, 0, 0 : +1 anomalie par rafale, + // premier point après ~31 paquets (1,5 s de chute, ~12 blocs). Simulé, à confirmer avec une trace réelle. + double total = chuteAvecGigue(new int[] {3, 0, 0}); + assertTrue(total > 0); + Mesures.noter("Lag 3,0,0 : " + total + " points de vol sur une chute de 80 paquets"); + } + + @Test + void honnete_gelDuServeurDeTroisSecondesEnPleineChute() { + auSol(3); + double total = chute(EtatJoueur.normal(), 0.42, 8); + total += paquet(EtatJoueur.normal(), m(0.1, -12.0, 60, false, false)); // 60 ticks : vitesse oubliée + total += chute(EtatJoueur.normal(), -2.5, 20); + assertEquals(0, total, 1e-9); + } + + @Test + void honnete_tpsBasLeVolNUtilisePasLeFacteurDeLagMaisLaChuteResteJuste() { + EtatJoueur lent = EtatJoueur.builder().tps(12).build(); + auSol(3); + assertEquals(0, chute(lent, 0.42, 60), 1e-9); + } +}