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 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
bbb08a95f8
révision
44504eca0c
1 fichier modifié
+363
@@ -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<Verdict> 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<Verdict> 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);
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur