Comparer les révisions

..
Auteur SHA1 Message Date

2026-10-16

gastineltetClaude Opus 5.5 d9530d0661 GastinelGarde autotests : temoin C1 grace bornee corrige
L ancien temoin (acceleration 0,02/tick2 prolongee) entre dans la tolerance de VolVertical apres ~22 ticks
et ne pouvait pas etre puni apres la grace. Remplace par un plane constant a -0,05 bloc/tick.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 05:58:28 +02:00
gastineltetClaude Opus 5.5 9335654541 GastinelGarde vol : correctif incident elytres du 15/10 (C1-C5)
C1 grace du controle vol apres la fin du plane en elytres (bornee, finie a l atterrissage).
C2 setback : vol et vitesse remis a zero, VL VOL/VITESSE a zero.
C3 position de retour seulement au sol serveur ou milieu special.
C4 expulsion a usage unique jusqu a la reconnexion, plus aucune evaluation entre-temps.
C5 expulsion seulement apres plusieurs setbacks recents. Jamais de bannissement.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 05:58:27 +02:00
gastineltetClaude Opus 5.5 56a98f3a5c GastinelGarde vol : tests C1-C5 inverses (CORRIGE_...), rouges avant correctif
Les tests FAUX_POSITIF_/FAILLE_ de l'incident VOL du 15/10 (C1, C2, C3, C4, C5)
exigent maintenant le bon comportement : grace de fin d'elytres, setback vers
une position au sol avec remise a zero du vol et des VL, escalade en plusieurs
setbacks, expulsion a usage unique, jamais de bannissement.
Squelette d'API sans effet dans Moteur et GardeConfig pour que les tests
compilent. Resultat : 253 tests, 5 echecs (attendus).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 05:10:45 +02:00
7 fichiers modifiés avec 212 ajouts et 83 suppressions

Aucun fichier ne correspond à votre recherche

+9 -1
Voir le fichier
@@ -547,6 +547,7 @@ public final class Garde {
/** Début du traitement d'un paquet de mouvement : contrôle du débit. */
public static void avantMouvement(ServerPlayer p) {
if (!surThreadServeur(p)) return; // F01 : jamais depuis le thread réseau (le mixin l'évite déjà)
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 : expulsion en cours, plus rien à évaluer
if (estExempteManuellement(p.getUUID())) return;
EtatJoueur etat = etat(p, false);
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
@@ -557,6 +558,7 @@ public final class Garde {
/** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */
public static void apresMouvement(ServerPlayer p) {
if (!surThreadServeur(p)) return;
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 / C6 : ni évaluation ni état recréé après l'expulsion
int tick = p.server.getTickCount();
Marques m = marques(p.getUUID());
boolean solServeur = auSolServeur(p, m);
@@ -601,7 +603,9 @@ public final class Garde {
// En véhicule, la position du joueur est celle du véhicule, non contrôlée ici : elle n'est mémorisée
// qu'après un paquet de véhicule sans verdict (apresVehicule), sinon un setback y ramènerait.
if (m.dernierVerdictTick != tick && !vehiculeControle(p)) {
// C3 (16/10) : seulement au sol vu par le serveur (ou eau, échelle…), jamais une position en l'air.
if (m.dernierVerdictTick != tick && !vehiculeControle(p)
&& MOTEUR.positionDeRetourAdmise(solServeur, em != null && em.milieuSpecial())) {
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
p.level().dimension().location().toString());
}
@@ -870,6 +874,8 @@ public final class Garde {
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
if (s == Sanction.EXPULSION) {
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
if (!MOTEUR.expulser(p.getUUID(), p.server.getTickCount() * 50L)) return;
ecrireJournal(p.getGameProfile().getName() + " EXPULSE (" + raison + ")");
p.connection.disconnect(Component.literal("Expulsé par l'anti-triche (" + raison + ")."));
} else if (s == Sanction.SETBACK) {
@@ -878,6 +884,8 @@ public final class Garde {
if (sv.aPositionValide() && sv.dimension().equals(dim)) {
annoncerTeleport(p, GraceTeleport.Origine.SETBACK);
p.connection.teleport(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
MOTEUR.apresSetback(p.getUUID(), p.server.getTickCount() * 50L);
ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")");
}
}
+8 -1
Voir le fichier
@@ -57,6 +57,10 @@ public final class GardeEvents {
@SubscribeEvent
public static void onAttaque(AttackEntityEvent event) {
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
if (Garde.moteur().estExpulse(p.getUUID())) { // C4 : expulsion en cours
event.setCanceled(true);
return;
}
if (Garde.estExempteManuellement(p.getUUID())) return;
Entity cible = event.getTarget();
@@ -135,7 +139,10 @@ public final class GardeEvents {
@SubscribeEvent
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
if (event.getEntity() instanceof ServerPlayer p) Garde.noterTeleport(p);
if (event.getEntity() instanceof ServerPlayer p) {
Garde.moteur().oublierExpulsion(p.getUUID()); // C4 : la marque d'expulsion vaut jusqu'à la reconnexion
Garde.noterTeleport(p);
}
}
@SubscribeEvent
+8
Voir le fichier
@@ -17,6 +17,14 @@ public final class GardeConfig {
public double seuilExpulsion = 20.0;
/** Sanction la plus forte autorisée (T4 : setback puis expulsion, jamais de bannissement). */
public Sanction sanctionMax = Sanction.EXPULSION;
/**
* C5 (16/10) : un retour en arrière remet le VL du contrôle à zéro ; l'expulsion pour un contrôle de mouvement
* vient quand ce nombre de setbacks a déjà eu lieu dans {@link #fenetreSetbacksMs}.
*/
public int setbacksAvantExpulsion = 4;
public long fenetreSetbacksMs = 60_000;
/** C1 (16/10) : ticks de grâce du contrôle vol après la fin du plané en élytres (fin à l'atterrissage). */
public int graceFinElytresTicks = 50;
// --- Killaura ---
/** Angle maximal entre le regard et la silhouette de la cible, en degrés. */
+71 -1
Voir le fichier
@@ -21,6 +21,8 @@ public final class Moteur {
private final GardeConfig cfg;
private final Map<UUID, Suivi> suivis = new HashMap<>();
/** C4 : joueurs déjà expulsés (jusqu'à leur reconnexion). */
private final java.util.Set<UUID> expulses = new java.util.HashSet<>();
public Moteur(GardeConfig cfg) {
this.cfg = cfg;
@@ -54,6 +56,7 @@ public final class Moteur {
*/
public List<Verdict> attaque(UUID joueur, long nowMs, EtatJoueur etat, double excedentDegres,
int idCible, boolean cibleVisible) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
if (ex.exempt()) return List.of();
@@ -97,6 +100,7 @@ public final class Moteur {
*/
public List<Verdict> porteeHitbox(UUID joueur, long nowMs, EtatJoueur etat, double distance, double manque,
double porteeJoueur, double vitesseCible) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
boolean portee = cfg.mode(Controle.PORTEE) != Mode.OFF;
boolean hitbox = cfg.mode(Controle.HITBOX) != Mode.OFF;
if (!portee && !hitbox) return List.of();
@@ -165,6 +169,7 @@ public final class Moteur {
double[] boite, double porteeJoueur, double vitesseCible,
boolean porteeHitbox, boolean angle, double[] oeilPrecedent,
double[][] boitesVues) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
List<Verdict> verdicts = terminerCoup(joueur);
boolean serie = porteeHitbox && boitesVues != null && boitesVues.length > 0
&& cfg.mode(Controle.COUPS_HORS_BOITE) != Mode.OFF;
@@ -224,6 +229,7 @@ public final class Moteur {
/** 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
Suivi s = suivis.get(joueur);
if (s == null || s.coupDiffere == null) return List.of();
if (s.coupDiffere.encoreValable(nowMs)) s.coupDiffere.affiner(oeil, regard);
@@ -270,6 +276,7 @@ public final class Moteur {
*/
public List<Verdict> regard(UUID joueur, long nowMs, java.util.function.Supplier<EtatJoueur> etat,
float yaw, float pitch) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
if (cfg.mode(Controle.ROTATION) == Mode.OFF) return List.of();
Suivi s = suivi(joueur);
double pts = s.rotation.regard(nowMs / 50, yaw, pitch);
@@ -285,6 +292,7 @@ public final class Moteur {
/** Un paquet de mouvement vient d'arriver (temps réel en ms, pour mesurer le débit). */
public List<Verdict> paquetMouvement(UUID joueur, long nowMs, EtatJoueur etat) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
if (cfg.mode(Controle.TIMER) == Mode.OFF) return List.of();
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER);
if (ex.exempt()) {
@@ -304,6 +312,7 @@ public final class Moteur {
* Les exemptions de mouvement (riptide, élytres, contraption, téléportation, recul…) coupent tout.
*/
public List<Verdict> mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
boolean noFall = cfg.mode(Controle.NO_FALL) != Mode.OFF;
boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF;
boolean vol = cfg.mode(Controle.VOL) != Mode.OFF;
@@ -315,6 +324,10 @@ public final class Moteur {
// 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…).
s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons()));
s.vol.vider();
// C1 (16/10, incident Rednixxu) : le drapeau élytres tombe côté serveur alors que le client plane encore.
if (ex.raisons().contains("elytres")) {
s.graceElytresJusquaMs = nowMs + cfg.graceFinElytresTicks * 50L;
}
return List.of();
}
List<Verdict> verdicts = new ArrayList<>(3);
@@ -328,7 +341,15 @@ public final class Moteur {
String.format(Locale.ROOT, "dxz=%.3f max=%.3f ticks=%d base=%.3f", m.dxz(),
s.vitesse.dernierPermis() * Math.max(1, m.ticks()), m.ticks(), VitesseHorizontale.vitesseMax(m)));
}
if (vol) {
boolean graceElytres = false;
if (m.auSolServeur()) {
s.graceElytresJusquaMs = Long.MIN_VALUE; // atterrissage : fin de la grâce de fin d'élytres
} else if (nowMs <= s.graceElytresJusquaMs) {
graceElytres = true;
}
if (vol && graceElytres) {
s.vol.vider(); // le paquet qui suit la grâce sert de référence
} else if (vol) {
double pts = s.vol.enregistrer(m, false);
ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy()));
}
@@ -350,6 +371,7 @@ public final class Moteur {
* Un mouvement de véhicule piloté par le joueur, accepté par le serveur (F20) : vitesse et vol du véhicule.
*/
public List<Verdict> vehicule(UUID joueur, long nowMs, EtatJoueur etat, EtatVehicule m) {
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
boolean vitesse = cfg.mode(Controle.VEHICULE_VITESSE) != Mode.OFF;
boolean vol = cfg.mode(Controle.VEHICULE_VOL) != Mode.OFF;
if (!vitesse && !vol) return List.of();
@@ -395,6 +417,49 @@ public final class Moteur {
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
}
// --- Setback, expulsion, position de retour (16/10, incident VOL) ----------------------------------------
/**
* C2 (16/10) : un retour en arrière vient d'être appliqué. Le contrôle vol et la vitesse repartent de zéro (le
* paquet suivant sert de référence) et leurs VL sont remis à zéro ; le setback est compté pour l'escalade (C5).
*/
public void apresSetback(UUID joueur, long nowMs) {
Suivi s = suivi(joueur);
s.vol.vider();
s.vitesse.vider();
s.graceElytresJusquaMs = Long.MIN_VALUE;
s.vl.remettreAZero(Controle.VOL);
s.vl.remettreAZero(Controle.VITESSE);
s.noterSetback(nowMs);
}
/**
* C4 (16/10) : expulsion à usage unique. Vrai la première fois seulement ; ensuite le joueur n'est plus évalué
* jusqu'à sa reconnexion ({@link #oublierExpulsion}). La marque survit à {@link #retirer} (C6).
*/
public boolean expulser(UUID joueur, long nowMs) {
return expulses.add(joueur);
}
public boolean estExpulse(UUID joueur) {
return expulses.contains(joueur);
}
/** Reconnexion du joueur : il repart d'un état neuf. */
public void oublierExpulsion(UUID joueur) {
expulses.remove(joueur);
suivis.remove(joueur);
}
/**
* C3 (16/10) : la position d'un paquet sans verdict ne sert de retour en arrière que si le joueur est au sol vu
* par le serveur (ou dans un milieu où la gravité vanilla ne s'applique pas : eau, échelle…). Avant, toute
* position était gardée, y compris pendant les 10 ticks anormaux tolérés : retour en l'air.
*/
public boolean positionDeRetourAdmise(boolean auSolServeur, boolean milieuSpecial) {
return auSolServeur || milieuSpecial;
}
// --- Interne ----------------------------------------------------------------------------------------
private void ajouter(List<Verdict> sortie, Suivi s, Controle c, double points, long nowMs,
@@ -403,6 +468,11 @@ public final class Moteur {
Mode mode = cfg.mode(c);
double vl = s.vl.ajouter(c, points, nowMs);
Sanction palier = Paliers.palier(vl, cfg);
// C5 (16/10) : après un setback, le VL repart de zéro ; l'expulsion vient après plusieurs setbacks récents.
if (palier == Sanction.SETBACK && cfg.setbacksAvantExpulsion > 0
&& s.setbacksRecents(nowMs, cfg.fenetreSetbacksMs) >= cfg.setbacksAvantExpulsion) {
palier = Sanction.min(Sanction.EXPULSION, cfg.sanctionMax);
}
Sanction applicable = Paliers.applicable(palier, mode);
boolean notifier = applicable.ordinal() >= Sanction.ALERTE.ordinal()
&& s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS);
+16
Voir le fichier
@@ -21,6 +21,22 @@ public final class Suivi {
CoupDiffere coupDiffere;
/** Jusqu'à quand (ms) les coups sont annulés après une sanction portée / hitbox en ENFORCE. */
long coupsBloquesJusqua = Long.MIN_VALUE;
/** C1 (16/10) : fin de la grâce du contrôle vol après le plané en élytres (ms). */
long graceElytresJusquaMs = Long.MIN_VALUE;
/** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */
private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>();
void noterSetback(long nowMs) {
setbacks.addLast(nowMs);
while (setbacks.size() > 32) setbacks.removeFirst();
}
/** Nombre de setbacks dans la fenêtre {@code fenetreMs} qui précède {@code nowMs}. */
int setbacksRecents(long nowMs, long fenetreMs) {
int n = 0;
for (long t : setbacks) if (nowMs - t <= fenetreMs) n++;
return n;
}
// Dernière position jugée valide (retour en arrière).
private boolean positionValide;
+5
Voir le fichier
@@ -42,6 +42,11 @@ public final class VlCompteur {
etats.clear();
}
/** C2 (16/10) : remet à zéro un seul contrôle (après un setback). */
public void remettreAZero(Controle c) {
etats.remove(c);
}
private double decayed(Etat e, long nowMs) {
if (nowMs <= e.dernierMs) return e.valeur;
double perdu = (nowMs - e.dernierMs) / 1000.0 * decroissanceParSeconde;
+95 -80
Voir le fichier
@@ -14,9 +14,9 @@ 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.
*
* Ces tests DOCUMENTENT le comportement actuel, ils ne corrigent rien : un test nommé {@code FAILLE_…} ou
* {@code FAUX_POSITIF_…} passe tant que le défaut existe. Quand le défaut sera corrigé, il échouera : il faudra alors
* inverser son assertion (c'est voulu, pour que la correction soit vue).
* 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.
*
* 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
@@ -67,7 +67,8 @@ class AutotestVolIncidentTest {
tick++;
y += m.dy();
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, e, m);
if (vs.isEmpty()) { // Garde.apresMouvement : m.dernierVerdictTick != tick
// Garde.apresMouvement : m.dernierVerdictTick != tick, et (16/10, C3) position admise (au sol serveur)
if (vs.isEmpty() && moteur.positionDeRetourAdmise(m.auSolServeur(), m.milieuSpecial())) {
yRetour = y;
retourAuSol = m.auSolServeur();
}
@@ -94,24 +95,46 @@ class AutotestVolIncidentTest {
return sortie;
}
// --- C1 : pas de grâce de sortie d'élytres pour le vol ----------------------------------------------------------
/** Plané anormal depuis le sol, sans élytres (triche de type « glide ») : de quoi déclencher des setbacks. */
private EtatMouvement plane() {
return air(-0.02);
}
// --- C1 : grâce de sortie d'élytres pour le vol (corrigé le 16/10) ----------------------------------------------
@Test
void FAUX_POSITIF_C1_planeDElytresDontLeDrapeauTombeEstPrisPourDuVol() {
void CORRIGE_C1_planeDElytresDontLeDrapeauTombeNEstPlusPrisPourDuVol() {
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
int premier = -1;
double total = 0;
for (int k = 0; k < vs.size(); k++) {
double p = points(vs.get(k), Controle.VOL);
if (p > 0 && premier < 0) premier = k + 1;
total += p;
for (List<Verdict> v : vs) total += points(v, Controle.VOL);
// Avant : premier point au 12e tick, 11,6 points en 19 ticks (incident de Rednixxu).
assertEquals(0, total, 1e-9, "grâce de fin d'élytres : la trace de Rednixxu ne donne plus rien");
Mesures.noter("C1 corrige : 19 ticks de plane sans drapeau = " + total + " point");
}
@Test
void CORRIGE_C1_laGraceDeFinDElytresEstBorneeDansLeTemps() {
// Témoin : un plané sans drapeau qui dure bien au-delà de la grâce finit par être vu.
// 16/10 : témoin corrigé. L'ancien (accélération 0,02 bloc/tick² prolongée) entre dans la tolérance de
// VolVertical (0,05) dès ~22 ticks et n'était donc jamais puni après 50 ticks de grâce, même sans grâce.
// Plané constant à -0,05 bloc/tick : écart ~0,077 à chaque tick, nettement anormal.
sautPuisPlaneSansDrapeau(1);
double total = 0;
for (int k = 0; k < cfg.graceFinElytresTicks + 30; k++) {
total += points(paquet(EtatJoueur.normal(), air(-0.05)), Controle.VOL);
}
// Prouvé : le 1er paquet après l'exemption sert de référence, les suivants sont tous « anormaux » ; le 12e tick
// de plané sans drapeau donne le premier point (journal réel : 13 ticks après la chute du drapeau, vl=1.1).
assertEquals(12, premier, "premier tick de plané puni");
assertEquals(1.1, points(vs.get(11), Controle.VOL), 1e-9);
assertTrue(total > cfg.seuilSetback, "19 ticks de plané suffisent à dépasser le seuil de setback");
Mesures.noter("C1 premier point au tick " + premier + " de plane sans drapeau ; total 19 ticks = " + total);
assertTrue(total > 0, "après la grâce, un plané anormal est de nouveau puni");
}
@Test
void CORRIGE_C1_laGraceSeTermineALAtterrissage() {
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
for (int i = 0; i < 20; i++) paquet(elytres, air(-0.3));
for (int i = 0; i < 3; i++) paquet(EtatJoueur.normal(), sol()); // atterrissage : fin de la grâce
double total = 0;
for (int i = 0; i < 20; i++) total += points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL);
assertTrue(total > 0, "voler juste après un atterrissage d'élytres reste vu");
}
@Test
@@ -127,102 +150,94 @@ class AutotestVolIncidentTest {
assertEquals(0, total, 1e-9, "réfuté : une fin d'élytres suivie d'une chute vanilla ne donne rien");
}
// --- C3 : point de retour mémorisé en l'air -----------------------------------------------------------------------
// --- C3 : point de retour au sol (corrigé le 16/10) --------------------------------------------------------------
@Test
void FAUX_POSITIF_C3_pointDeRetourMemoriseEnLAirSousLaPlateforme() {
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(12);
assertTrue(points(vs.get(11), Controle.VOL) > 0);
assertFalse(retourAuSol, "la position de retour vient d'un paquet en l'air");
assertTrue(yRetour < Y_SOL, "et elle est sous la plateforme d'où il a sauté : " + yRetour);
Mesures.noter(String.format(java.util.Locale.ROOT,
"C3 retour en l'air a y=%.3f (sol %.3f, ecart %.3f ; journal reel : 109,685, ecart 1,19)",
yRetour, Y_SOL, Y_SOL - yRetour));
void CORRIGE_C3_pointDeRetourResteAuSolPendantUnPlane() {
sautPuisPlaneSansDrapeau(12);
assertTrue(retourAuSol, "la position de retour vient d'un paquet au sol serveur");
assertEquals(Y_SOL, yRetour, 1e-9, "et c'est la plateforme d'où il a sauté");
}
@Test
void FAILLE_C3_unVolDeDixTicksGardeLAltitudeGagneeDansLePointDeRetour() {
void CORRIGE_C3_unVolDeDixTicksNeGardePasLAltitudeGagnee() {
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
int premier = -1;
for (int k = 1; k <= 15 && premier < 0; k++) {
if (points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL) > 0) premier = k;
}
assertTrue(premier > 10, "le vol n'est vu qu'après 10 ticks anormaux");
assertFalse(retourAuSol);
assertTrue(yRetour - Y_SOL >= 0.9, "le setback ramène à l'altitude gagnée en volant : +" + (yRetour - Y_SOL));
Mesures.noter(String.format(java.util.Locale.ROOT, "C3 tricheur : retour a +%.2f bloc au-dessus du sol",
yRetour - Y_SOL));
assertTrue(retourAuSol);
assertEquals(Y_SOL, yRetour, 1e-9, "le setback ramène au sol de départ, pas à l'altitude gagnée");
}
// --- C2, C5, C4 : setback sans remise à zéro, escalade en moins d'une seconde, expulsion répétée ------------------
// --- C2, C5, C4 : setback remis à zéro, escalade, expulsion unique (corrigés le 16/10) ---------------------------
@Test
void FAUX_POSITIF_C2_setbackNOuvreAucuneGraceEtNeRemetPasLeVolAZero() {
GraceTeleport g = new GraceTeleport();
g.annoncer(GraceTeleport.Origine.SETBACK);
assertFalse(g.teleport(), "le setback n'ouvre pas la grâce de téléportation");
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
int k = 0;
while (Verdict.pire(vs.get(k)) != Sanction.SETBACK) k++; // premier SETBACK
// Modèle de l'adaptateur : teleport() vers le point de retour ; le paquet suivant n'est pas mesuré.
tick++;
/** Modèle de Garde.appliquerSanctionMouvement (SETBACK) : téléportation au point de retour puis remise à zéro. */
private void setback() {
moteur.apresSetback(joueur, tick * 50L);
tick++; // teleport() : le paquet suivant n'est pas mesuré (Garde.teleportVanilla)
y = yRetour;
// Joueur gelé en l'air au point de retour (dy = 0, gravité absente tant que la téléportation n'est pas
// confirmée : « kicked for floating too long » x302 dans le journal du 15/10).
for (int i = 0; i < 5; i++) {
List<Verdict> v = paquet(EtatJoueur.normal(), air(0));
assertTrue(points(v, Controle.VOL) > 0, "paquet gelé " + i + " après le setback encore puni");
}
}
@Test
void FAUX_POSITIF_C5_C4_cinqSetbacksPuisExpulsionEnMoinsDUneSecondeEtExpulsionRepetee() {
void CORRIGE_C2_apresUnSetbackLeVolEtLesVlRepartentDeZero() {
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
double v = 0.42;
int n = 0;
while (Verdict.pire(paquet(EtatJoueur.normal(), plane())) != Sanction.SETBACK) assertTrue(++n < 100);
assertTrue(retourAuSol, "point de retour au sol");
setback();
assertEquals(0, moteur.suivi(joueur).vl.valeur(Controle.VOL, tick * 50L), 1e-9, "VL de vol remis à zéro");
// Le client, ramené au sol, reste immobile quelques paquets (téléportation pas encore confirmée) : rien.
for (int i = 0; i < 5; i++) {
paquet(EtatJoueur.normal(), air(v));
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
List<Verdict> v = paquet(EtatJoueur.normal(), sol());
assertEquals(0, points(v, Controle.VOL), 1e-9, "paquet " + i + " après le setback");
}
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
for (int i = 0; i < 7; i++) paquet(elytres, air(-0.05));
// Et même gelé en l'air une demi-seconde (ancien scénario), le compteur repart de zéro : pas de point.
double total = 0;
for (int i = 0; i < 10; i++) total += points(paquet(EtatJoueur.normal(), air(0)), Controle.VOL);
assertEquals(0, total, 1e-9);
}
@Test
void CORRIGE_C5_C4_escaladeEnPlusDUneSecondeEtExpulsionUnique() {
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
int premierPointTick = -1, setbacks = 0, expulsionTick = -1;
double dyPlane = 0;
boolean gele = false;
for (int n = 0; n < 200 && expulsionTick < 0; n++) {
EtatMouvement m;
if (gele) {
m = air(0);
} else {
dyPlane -= 0.02;
m = air(dyPlane);
}
List<Verdict> vs = paquet(EtatJoueur.normal(), m);
for (int n = 0; n < 2000 && expulsionTick < 0; n++) {
List<Verdict> vs = paquet(EtatJoueur.normal(), plane());
if (points(vs, Controle.VOL) > 0 && premierPointTick < 0) premierPointTick = tick;
Sanction s = Verdict.pire(vs);
if (s == Sanction.SETBACK) {
setbacks++;
gele = true;
tick++; // teleport() : le paquet suivant n'est pas mesuré (Garde.teleportVanilla)
y = yRetour;
setback();
paquet(EtatJoueur.normal(), sol()); // de retour au sol, le tricheur recommence
} else if (s == Sanction.EXPULSION) {
expulsionTick = tick;
}
}
assertTrue(expulsionTick > 0, "expulsion atteinte");
assertTrue(expulsionTick > 0, "un tricheur obstiné finit expulsé");
int duree = expulsionTick - premierPointTick;
Mesures.noter("C5 premier point -> expulsion : " + duree + " ticks (" + duree * 50 + " ms), " + setbacks
+ " setbacks (journal reel : 5 setbacks, expulsion a la 1re seconde)");
assertTrue(duree < 20, "moins d'une seconde entre le premier point et l'expulsion : " + duree + " ticks");
assertTrue(setbacks >= 3 && setbacks <= 6, "quelques setbacks seulement : " + setbacks);
Mesures.noter("C5 corrige : premier point -> expulsion : " + duree + " ticks (" + duree * 50 + " ms), "
+ setbacks + " setbacks");
assertTrue(duree >= 40, "au moins 2 s entre le premier point et l'expulsion : " + duree + " ticks");
assertEquals(cfg.setbacksAvantExpulsion, setbacks, "l'expulsion vient après plusieurs setbacks distincts");
// C4 (partie moteur) : rien ne retient « déjà expulsé » ; chaque paquet suivant redonne une EXPULSION.
int expulsionsSuivantes = 0;
for (int i = 0; i < 20; i++) {
if (Verdict.pire(paquet(EtatJoueur.normal(), air(0))) == Sanction.EXPULSION) expulsionsSuivantes++;
}
assertEquals(20, expulsionsSuivantes, "chaque paquet après l'expulsion rend encore EXPULSION");
// C4 : l'expulsion est à usage unique ; le moteur ne rend plus rien pour ce joueur.
assertTrue(moteur.expulser(joueur, tick * 50L), "première expulsion acceptée");
assertFalse(moteur.expulser(joueur, tick * 50L), "deuxième demande refusée");
int verdictsSuivants = 0;
for (int i = 0; i < 20; i++) verdictsSuivants += paquet(EtatJoueur.normal(), plane()).size();
assertEquals(0, verdictsSuivants, "aucun verdict après l'expulsion");
// C6 : même si l'état du joueur est retiré pendant disconnect(), la marque d'expulsion reste.
moteur.retirer(joueur);
assertFalse(moteur.expulser(joueur, tick * 50L));
moteur.oublierExpulsion(joueur); // reconnexion
assertTrue(moteur.expulser(joueur, tick * 50L));
}
@Test
void jamaisDeBannissement() {
for (Sanction s : Sanction.values()) assertFalse(s.name().contains("BAN"), "sanction " + s);
}
@Test