Comparer les révisions

...
Auteur SHA1 Message Date

2026-10-16

gastineltetClaude Opus 5.5 3dc39c8043 GastinelGarde : correctifs C7, C8, C18 derriere options desactivees par defaut
- C7 elytresExemptionStricte : plane declenche moins de elytresAirMinTicks (2)
  ticks apres le dernier sol serveur = pas d exemption de mouvement ;
  portee/hitbox mesurees pendant le plane.
- C8 combatMesureEnVehicule : passager mesure comme a pied (contraption reste exemptee).
- C18 empilementSeulementEnMouvement : minecart contenant immobile non casse, journalise.
266 tests, 0 echec (cornafserver).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:02:09 +02:00
gastineltetClaude Opus 5.5 5eeb916add GastinelGarde tests inverses CORRIGE_C7, C8, C18 (rouges) et ebauches sans effet
Options desactivees par defaut : elytresExemptionStricte, elytresAirMinTicks,
combatMesureEnVehicule, empilementSeulementEnMouvement ; champ
EtatJoueur.elytresDeploiementSuspect ; AntiCrashEntites.empilementACasser.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:32:46 +02:00
gastineltetClaude Opus 5.5 f19fe6444b GastinelGarde tests : FAILLE_C7, FAILLE_C8, FAUX_POSITIF_C18 (verts tant que le defaut existe)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:31:36 +02:00
gastineltetClaude Opus 5.5 9c2814a30e GastinelGarde vol : rafales reseau, ticks dus bornes (AVANCE_MAX = 4)
Un paquet d un tick client recu apres n ticks serveur peut couvrir 1 tick ; les ticks dus
sont couverts par les paquets a 0 tick suivants. Ensemble de ticks candidats = sur-ensemble
de l ancien (jamais plus strict). Actif sans option : c est le correctif d un faux positif.
260 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:16:34 +02:00
gastineltetClaude Opus 5.5 e33225c0d0 GastinelGarde : tests rafales reseau inverses (CORRIGE_...), rouges avant correctif
3 echecs attendus : CORRIGE_lagRafalesDeTrois (ex FAUX_POSITIF_), CORRIGE_rafalesDeTrois, CORRIGE_sautPuisChute.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:15:33 +02:00
gastineltetClaude Opus 5.5 b34a3b3aeb GastinelGarde autotests : rafales reseau (FAUX_POSITIF_ verts tant que le defaut existe)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:14:38 +02:00
13 fichiers modifiés avec 310 ajouts et 8 suppressions

Aucun fichier ne correspond à votre recherche

+2
Voir le fichier
@@ -159,6 +159,8 @@
#Minecarts superposés au plus : au-delà, poussée mutuelle coupée et excédentaires (sans passager) cassés. 0 = pas de limite.
# Range: 0 ~ 64
minecartsSuperposesMax = 4
#C18 : ne casser que les minecarts empilés en mouvement ou sans contenu (défaut false, décision de Théo)
empilementSeulementEnMouvement = false
alertesOps = true
#Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs.
+18
Voir le fichier
@@ -80,6 +80,10 @@ public final class Garde {
int contraptionTick = Integer.MIN_VALUE;
int contraptionVuTick = Integer.MIN_VALUE;
boolean contraptionProche;
// C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours
int solServeurTick = Integer.MIN_VALUE;
boolean elytresVues;
boolean elytresSuspectes;
// Cache de la détection d'un courant d'air (ventilateur Create), même principe
int courantTick = Integer.MIN_VALUE;
int courantVuTick = Integer.MIN_VALUE;
@@ -386,12 +390,25 @@ public final class Garde {
mange = anim == UseAnim.EAT || anim == UseAnim.DRINK;
}
// C7 : au début du plané, combien de ticks en l'air (sol serveur) ? Moins que elytresAirMinTicks : suspect.
if (p.isFallFlying()) {
if (!m.elytresVues) {
m.elytresVues = true;
m.elytresSuspectes = m.solServeurTick != Integer.MIN_VALUE
&& tick - m.solServeurTick < config().elytresAirMinTicks;
}
} else {
m.elytresVues = false;
m.elytresSuspectes = false;
}
return EtatJoueur.builder()
.creatif(p.isCreative())
.spectateur(p.isSpectator())
.peutVoler(p.getAbilities().mayfly)
.riptide(riptideRecent)
.elytres(p.isFallFlying())
.elytresDeploiementSuspect(m.elytresSuspectes)
.levitation(p.hasEffect(MobEffects.LEVITATION))
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
.enVehicule(p.isPassenger())
@@ -586,6 +603,7 @@ public final class Garde {
int tick = p.server.getTickCount();
Marques m = marques(p.getUUID());
boolean solServeur = auSolServeur(p, m);
if (solServeur) m.solServeurTick = tick; // C7
// Phase 2 : no-fall (divergence), vitesse horizontale, vol.
boolean controler = mouvementControlesActifs() && !estExempteManuellement(p.getUUID());
+11
Voir le fichier
@@ -137,6 +137,17 @@ public final class GardeAntiCrash {
if (!AntiCrashEntites.empilementExcessif(n, r)) return false;
if (cart.isVehicle() || Garde.estContraption(cart) || SableAcces.surSousNiveau(cart)) return false;
Vec3 v = cart.getDeltaMovement();
// C18 : avec l'option, un minecart contenant immobile (stockage) n'est pas cassé.
boolean contenant = cart instanceof net.minecraft.world.Container;
if (!AntiCrashEntites.empilementACasser(n, r, v.length(), contenant)) {
if (plafonnementASignaler(cart.getUUID())) {
Garde.journaliser(String.format(java.util.Locale.ROOT,
"anti-crash EMPILEMENT %s immobile garde (%d minecarts superposés > %d), dim=%s pos=(%.1f, %.1f, %.1f)",
BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()), n, r.empilementMax,
cart.level().dimension().location(), cart.getX(), cart.getY(), cart.getZ()));
}
return false;
}
cart.destroy(cart.getPickResult().getItem());
String type = BuiltInRegistries.ENTITY_TYPE.getKey(cart.getType()).toString();
String ligne = String.format(java.util.Locale.ROOT,
+19
Voir le fichier
@@ -53,6 +53,10 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX;
private static final ModConfigSpec.BooleanValue VOL_FENETRE_GLISSANTE;
private static final ModConfigSpec.BooleanValue VITESSE_MOYENNE;
private static final ModConfigSpec.BooleanValue ELYTRES_STRICTE;
private static final ModConfigSpec.IntValue ELYTRES_AIR_MIN;
private static final ModConfigSpec.BooleanValue COMBAT_VEHICULE;
private static final ModConfigSpec.BooleanValue AC_EMPILEMENT_MOUVEMENT;
private static final ModConfigSpec.DoubleValue SERIE_MANQUE;
private static final ModConfigSpec.DoubleValue SERIE_PORTEE;
private static final ModConfigSpec.IntValue SERIE_COUPS;
@@ -161,6 +165,14 @@ public final class GardeSpec {
VITESSE_MOYENNE = b.comment("C15 : vitesse moyenne sur 40 paquets comparée à la moyenne vanilla (course, sprint-saut).",
"Désactivé par défaut : à essayer en OBSERVE (fausse alerte possible sous un plafond bas, C16).")
.define("vitesseMoyenne", false);
ELYTRES_STRICTE = b.comment("C7 : plané déclenché sans ticks en l'air (sol serveur) = pas d'exemption de mouvement ;",
"portée et hitbox mesurées pendant le plané. Désactivé par défaut : à essayer en OBSERVE.")
.define("elytresExemptionStricte", false);
ELYTRES_AIR_MIN = b.comment("C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres.")
.defineInRange("elytresAirMinTicks", 2, 1, 20);
COMBAT_VEHICULE = b.comment("C8 : le combat d'un passager de véhicule (bateau, cheval, minecart) est mesuré comme à pied.",
"Désactivé par défaut : à essayer en OBSERVE (portée, hitbox, killaura).")
.define("combatMesureEnVehicule", false);
b.pop();
b.push("exemptions");
@@ -210,6 +222,9 @@ public final class GardeSpec {
AC_EMPILEMENT_MAX = b.comment("Minecarts au plus qui se chevauchent : au-delà, leur poussée mutuelle est coupée et les",
"excédentaires (sans passager) sont cassés et lâchent leur objet. 0 = pas de limite.")
.defineInRange("minecartsSuperposesMax", 4, 0, 64);
AC_EMPILEMENT_MOUVEMENT = b.comment("C18 : ne casser que les minecarts empilés en mouvement ou sans contenu ; un stockage",
"immobile de minecarts à coffre / à trémie n'est plus cassé (poussée coupée, journal seulement). Défaut false.")
.define("empilementSeulementEnMouvement", false);
AC_ALERTES_OPS = b.comment("Message aux ops (5 au plus par 10 s ; tout est dans logs/gastinelgarde.log).")
.define("alertesOps", true);
b.pop();
@@ -267,6 +282,9 @@ public final class GardeSpec {
c.timerSoldeMax = TIMER_SOLDE_MAX.get();
c.volFenetreGlissante = VOL_FENETRE_GLISSANTE.get();
c.vitesseMoyenne = VITESSE_MOYENNE.get();
c.elytresExemptionStricte = ELYTRES_STRICTE.get();
c.elytresAirMinTicks = ELYTRES_AIR_MIN.get();
c.combatMesureEnVehicule = COMBAT_VEHICULE.get();
c.serieManqueBlocs = SERIE_MANQUE.get();
c.seriePorteeMargeBlocs = SERIE_PORTEE.get();
c.serieCoups = SERIE_COUPS.get();
@@ -341,6 +359,7 @@ public final class GardeSpec {
r.margeBordure = l ? AC_MARGE_BORDURE.get() : AC_MARGE_BORDURE.getDefault();
r.vitesseMaxMinecart = l ? AC_VITESSE_MINECART.get() : AC_VITESSE_MINECART.getDefault();
r.empilementMax = l ? AC_EMPILEMENT_MAX.get() : AC_EMPILEMENT_MAX.getDefault();
r.empilementSeulementEnMouvement = l ? AC_EMPILEMENT_MOUVEMENT.get() : AC_EMPILEMENT_MOUVEMENT.getDefault();
return r;
}
+19
Voir le fichier
@@ -48,6 +48,14 @@ public final class AntiCrashEntites {
public double vitesseMaxMinecart = 3.0;
/** Minecarts au plus qui se chevauchent ; au-delà, la poussée mutuelle est coupée et les excédentaires cassés. */
public int empilementMax = 4;
/**
* C18 (16/10) : ne casser que les minecarts en mouvement ou sans contenu (minecart simple). Les minecarts à
* coffre / à trémie immobiles d'un stockage honnête ne sont plus cassés (poussée coupée, journal seulement).
* Désactivé par défaut : décision de Théo.
*/
public boolean empilementSeulementEnMouvement = false;
/** C18 : vitesse (blocs/tick) au-delà de laquelle un minecart empilé est « en mouvement ». */
public double empilementVitesseMin = 0.05;
}
/** Bordure du monde (rectangle horizontal). */
@@ -136,6 +144,17 @@ public final class AntiCrashEntites {
return r != null && r.actif && r.empilementMax > 0 && minecartsQuiSeChevauchent > r.empilementMax;
}
/**
* C18 : ce minecart empilé doit-il être cassé ?
* @param vitesse norme de sa vitesse (blocs/tick)
* @param contenant minecart à coffre, à trémie… (casser répand le contenu)
*/
public static boolean empilementACasser(int minecartsQuiSeChevauchent, Reglages r, double vitesse, boolean contenant) {
if (!empilementExcessif(minecartsQuiSeChevauchent, r)) return false;
if (!r.empilementSeulementEnMouvement) return true;
return !contenant || !(vitesse <= r.empilementVitesseMin);
}
/** Position dans la bordure + marge, et dans les limites absolues du jeu. */
public static boolean dansLimites(Bordure b, double marge, double x, double y, double z) {
if (Math.abs(x) > LIMITE_HORIZONTALE || Math.abs(z) > LIMITE_HORIZONTALE || Math.abs(y) > LIMITE_VERTICALE) {
+5 -2
Voir le fichier
@@ -15,6 +15,7 @@ public record EtatJoueur(
boolean enVehicule,
boolean pocheContraption,
boolean utiliseObjet,
boolean elytresDeploiementSuspect,
int ticksDepuisTeleport,
int ticksDepuisRecul,
int ticksDepuisGel,
@@ -34,7 +35,7 @@ public record EtatJoueur(
public static final class Builder {
private boolean creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente;
private boolean enVehicule, pocheContraption, utiliseObjet;
private boolean enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect;
private int ticksDepuisTeleport = JAMAIS, ticksDepuisRecul = JAMAIS, ticksDepuisGel = JAMAIS;
private double tps = 20.0;
private int pingMs = 30;
@@ -49,6 +50,8 @@ public record EtatJoueur(
public Builder enVehicule(boolean v) { enVehicule = v; return this; }
public Builder pocheContraption(boolean v) { pocheContraption = v; return this; }
public Builder utiliseObjet(boolean v) { utiliseObjet = v; return this; }
/** C7 : plané déclenché sans assez de ticks en l'air côté serveur (onGround probablement falsifié). */
public Builder elytresDeploiementSuspect(boolean v) { elytresDeploiementSuspect = v; return this; }
public Builder ticksDepuisTeleport(int v) { ticksDepuisTeleport = v; return this; }
public Builder ticksDepuisRecul(int v) { ticksDepuisRecul = v; return this; }
public Builder ticksDepuisGel(int v) { ticksDepuisGel = v; return this; }
@@ -57,7 +60,7 @@ public record EtatJoueur(
public EtatJoueur build() {
return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente,
enVehicule, pocheContraption, utiliseObjet, ticksDepuisTeleport, ticksDepuisRecul,
enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect, ticksDepuisTeleport, ticksDepuisRecul,
ticksDepuisGel, tps, pingMs);
}
}
+5 -2
Voir le fichier
@@ -28,13 +28,16 @@ public final class Exemptions {
switch (famille) {
case COMBAT -> {
if (e.enVehicule()) raisons.add("vehicule");
// C8 (16/10) : option combatMesureEnVehicule (défaut false) : le passager est mesuré comme à pied.
if (e.enVehicule() && !cfg.combatMesureEnVehicule) raisons.add("vehicule");
if (e.pocheContraption()) raisons.add("contraption");
}
case MOUVEMENT -> {
if (e.peutVoler()) raisons.add("peut-voler");
if (e.riptide()) raisons.add("riptide");
if (e.elytres()) raisons.add("elytres");
// C7 (16/10) : option elytresExemptionStricte (défaut false) : un plané déclenché sans ticks en l'air
// côté serveur (onGround falsifié) n'exempte plus le mouvement.
if (e.elytres() && !(cfg.elytresExemptionStricte && e.elytresDeploiementSuspect())) raisons.add("elytres");
if (e.levitation()) raisons.add("levitation");
if (e.chuteLente()) raisons.add("chute-lente");
if (e.enVehicule()) raisons.add("vehicule");
+11
Voir le fichier
@@ -97,6 +97,17 @@ public final class GardeConfig {
public boolean volFenetreGlissante = false;
/** C15 : vitesse moyenne sur 2 s comparée à la moyenne vanilla (course, sprint-saut). */
public boolean vitesseMoyenne = false;
// --- C7 / C8 (16/10, constats hauts) : DÉSACTIVÉS par défaut (à valider en OBSERVE) ---
/**
* C7 : élytres. Pas d'exemption de mouvement si le plané a été déclenché sans au moins
* {@link #elytresAirMinTicks} ticks en l'air (sol serveur), et portée / hitbox mesurées pendant le plané.
*/
public boolean elytresExemptionStricte = false;
/** C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres. */
public int elytresAirMinTicks = 2;
/** C8 : le combat d'un passager de véhicule (bateau, cheval, minecart…) est mesuré comme à pied. */
public boolean combatMesureEnVehicule = 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;
+1 -1
Voir le fichier
@@ -98,7 +98,7 @@ public final class PorteeHitbox {
*/
public static String raisonNonMesure(EtatJoueur e, double vitesseCible, GardeConfig cfg) {
if (e.riptide()) return "riptide";
if (e.elytres()) return "elytres";
if (e.elytres() && !cfg.elytresExemptionStricte) return "elytres"; // C7 : mesuré avec l'option
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) return "teleportation";
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) return "recul";
if (vitesseCible > cfg.vitesseCibleMaxMesure) return "cible-rapide";
+17 -1
Voir le fichier
@@ -19,6 +19,15 @@ public final class VolVertical {
private boolean etaitEnAir;
private int anormauxConsecutifs;
/**
* Rafales réseau (16/10) : ticks serveur écoulés moins ticks client couverts par les paquets déjà vus. Un paquet
* d'un tick client reçu après 3 ticks serveur laisse 2 ticks « dus », couverts ensuite par les paquets à 0 tick de
* la même rafale. Borné à {@link #AVANCE_MAX} : au-delà, on revient à la règle stricte (n-1 ou n ticks), donc
* un client qui ralentit durablement sa chute (un tick de gravité toutes les 3 ticks) reste vu.
*/
public static final int AVANCE_MAX = 4;
private int avance;
// --- C10 (16/10) : option {@link GardeConfig#volFenetreGlissante}, désactivée par défaut ---
/** Fenêtre glissante (ticks en l'air évalués) où l'on compte les ticks anormaux. */
public static final int FENETRE_TICKS = 20;
@@ -53,6 +62,7 @@ public final class VolVertical {
int n = e.ticks();
if (n > TICKS_MAX || n < 0) {
aVitesse = false;
avance = 0;
return 0;
}
boolean enAir = !e.auSolServeur();
@@ -62,11 +72,14 @@ public final class VolVertical {
if (exempt || e.milieuSpecial() || !enAir) {
anormauxConsecutifs = 0;
avance = 0;
viderFenetre();
} else if (etaitEnAir && aVitesse) {
// Ticks candidats couverts par ce paquet : n exactement à l'heure ; n-1 ou n en retard ; 1 si 0.
int kMin = n <= 1 ? 1 : n - 1;
// Rafales : jusqu'à AVANCE_MAX ticks dus peuvent rester en attente ; la règle d'avant reste toujours admise.
int kMin = Math.max(1, Math.min(n <= 1 ? 1 : n - 1, n + avance - AVANCE_MAX));
int kMax = Math.max(1, n);
int kRetenu = kMax;
boolean ecart = true;
double v = derniereVitesse;
double somme = 0;
@@ -78,8 +91,10 @@ public final class VolVertical {
if (k >= kMin && Math.abs(dy - somme) <= TOLERANCE * k) {
ecart = false;
vitesseFin = n <= 1 ? dy : v;
kRetenu = k;
}
}
avance = Math.max(0, Math.min(AVANCE_MAX, avance + n - kRetenu));
// Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08 par tick.
if (ecart) anormauxConsecutifs++;
else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1);
@@ -136,6 +151,7 @@ public final class VolVertical {
aVitesse = false;
etaitEnAir = false;
anormauxConsecutifs = 0;
avance = 0;
viderFenetre();
}
}
+4 -2
Voir le fichier
@@ -336,12 +336,14 @@ class AutotestCasLimitesTest {
}
@Test
void FAUX_POSITIF_lagRafalesDeTroisPaquetsPendantUneLongueChute() {
void CORRIGE_lagRafalesDeTroisPaquetsPendantUneLongueChute() {
// Inversé le 16/10 (fix/rafales-reseau) : était FAUX_POSITIF_ (88,9 points).
// Ancien commentaire :
// 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);
assertEquals(0, total, 1e-9);
Mesures.noter("Lag 3,0,0 : " + total + " points de vol sur une chute de 80 paquets");
}
+91
Voir le fichier
@@ -0,0 +1,91 @@
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.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.Exemptions.Famille;
import org.junit.jupiter.api.Test;
/**
* Constats de gravité haute restants de l'autocritique du 16/10 (C7, C8, C18).
* Tests inversés (CORRIGE_) : options désactivées par défaut, vérifiées activées ; défaut inchangé vérifié aussi.
*/
class AutotestConstatsHautsTest {
private final GardeConfig cfg = new GardeConfig();
private GardeConfig strict() {
GardeConfig c = new GardeConfig();
c.elytresExemptionStricte = true;
c.combatMesureEnVehicule = true;
return c;
}
// C7 : élytres déployées depuis le sol (onGround falsifié) : plus d'exemption de mouvement avec l'option.
@Test
void CORRIGE_C7_elytresDeployeesAuSolNExemptentPlus() {
EtatJoueur suspect = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(true).build();
assertFalse(Exemptions.evaluer(suspect, strict(), Famille.MOUVEMENT).raisons().contains("elytres"));
// Le mouvement est alors contrôlé : un vol plat soutenu donne des points.
Moteur m = new Moteur(strict());
java.util.UUID j = java.util.UUID.randomUUID();
double pts = 0;
for (int i = 0; i < 60; i++) {
for (Verdict v : m.mouvement(j, i * 50L, suspect,
new EtatMouvement(0.3, 0.0, 1, false, false, true, false, false, 0, 0, false, false))) pts += v.points();
}
assertTrue(pts > 0, "vol plat en élytres suspectes : " + pts);
}
// C7 témoin : plané honnête (déployé en l'air) toujours exempté, avec ou sans l'option ; défaut inchangé.
@Test
void temoin_C7_planeHonneteToujoursExempte() {
EtatJoueur honnete = EtatJoueur.builder().elytres(true).build();
assertTrue(Exemptions.evaluer(honnete, strict(), Famille.MOUVEMENT).raisons().contains("elytres"));
EtatJoueur suspect = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(true).build();
assertTrue(Exemptions.evaluer(suspect, cfg, Famille.MOUVEMENT).raisons().contains("elytres"), "défaut inchangé");
}
// C7 : portée / hitbox mesurées pendant le plané avec l'option.
@Test
void CORRIGE_C7_porteeMesureeEnElytres() {
EtatJoueur e = EtatJoueur.builder().elytres(true).build();
assertNull(PorteeHitbox.raisonNonMesure(e, 0.0, strict()));
assertEquals("elytres", PorteeHitbox.raisonNonMesure(e, 0.0, cfg), "défaut inchangé");
}
// C8 : passager d'un véhicule : combat mesuré avec l'option.
@Test
void CORRIGE_C8_combatMesureEnVehicule() {
EtatJoueur e = EtatJoueur.builder().enVehicule(true).build();
assertFalse(Exemptions.evaluer(e, strict(), Famille.COMBAT).exempt());
Moteur m = new Moteur(strict());
java.util.UUID j = java.util.UUID.randomUUID();
int verdicts = 0;
for (int i = 0; i < 40; i++) verdicts += m.attaque(j, i * 50L, e, 170.0, 1, true).size();
assertTrue(verdicts > 0);
assertTrue(Exemptions.evaluer(e, cfg, Famille.COMBAT).exempt(), "défaut inchangé");
// La contraption reste une exemption (constat : la garder pour le combat sur contraption).
assertTrue(Exemptions.evaluer(EtatJoueur.builder().pocheContraption(true).build(), strict(), Famille.COMBAT).exempt());
}
// C18 : stockage immobile de minecarts à coffre non cassé avec l'option ; empilement en mouvement ou simple cassé.
@Test
void CORRIGE_C18_stockageImmobileNonCasse() {
AntiCrashEntites.Reglages r = new AntiCrashEntites.Reglages();
r.empilementSeulementEnMouvement = true;
assertFalse(AntiCrashEntites.empilementACasser(6, r, 0.0, true));
assertTrue(AntiCrashEntites.empilementACasser(6, r, 0.5, true));
assertTrue(AntiCrashEntites.empilementACasser(6, r, 0.0, false));
assertFalse(AntiCrashEntites.empilementACasser(3, r, 0.5, false));
AntiCrashEntites.Reglages d = new AntiCrashEntites.Reglages();
assertTrue(AntiCrashEntites.empilementACasser(6, d, 0.0, true), "défaut inchangé");
}
@Test
void temoin_portee_mesureeAPiedSansElytres() {
assertNull(PorteeHitbox.raisonNonMesure(EtatJoueur.normal(), 0.0, cfg));
}
}
+107
Voir le fichier
@@ -0,0 +1,107 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
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 : rafales réseau (paquets de mouvement groupés après un lag). Chaque paquet couvre UN tick
* client, mais le serveur voit {@code motif[i]} ticks écoulés avant lui (3, 0, 0 : trois paquets arrivés ensemble).
*
* {@code CORRIGE_…} : anciens FAUX_POSITIF_ (joueur honnête puni), inversés : aucun point attendu.
* {@code temoin_…} : la triche équivalente (chute ralentie) doit rester vue, avant comme après le correctif.
*/
class AutotestRafalesTest {
private Moteur moteur;
private final UUID joueur = UUID.randomUUID();
private long tick;
private boolean sanctionLourde;
@BeforeEach
void init() {
GardeConfig 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;
sanctionLourde = false;
}
private static EtatMouvement m(double dy, int ticks, boolean sol) {
return new EtatMouvement(0.1, dy, ticks, sol, sol, false, false, false, 0, 0, false, false);
}
private double paquet(EtatMouvement mv) {
tick += mv.ticks();
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, EtatJoueur.normal(), mv);
double p = 0;
for (Verdict v : vs) {
if (v.controle() == Controle.VOL) p += v.points();
if (v.palier() == Sanction.SETBACK || v.palier() == Sanction.EXPULSION) sanctionLourde = true;
}
return p;
}
/** Chute honnête de {@code paquets} ticks client depuis la vitesse v0, avec la gigue donnée. */
private double chute(double v0, int paquets, int[] motif) {
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
double total = 0, v = v0;
for (int p = 0; p < paquets; p++) {
total += paquet(m(v, motif[p % motif.length], false));
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
}
return total;
}
@Test
void CORRIGE_rafalesDeTroisLongueChuteSansPointNiSanction() {
double total = chute(0, 80, new int[] {3, 0, 0});
Mesures.noter("Rafales 3,0,0 chute 80 : " + total + " points, sanction lourde=" + sanctionLourde);
assertEquals(0, total, 1e-9);
assertTrue(!sanctionLourde, "aucun setback ni expulsion pour un joueur honnête");
}
@Test
void CORRIGE_sautPuisChuteEnRafalesDeTrois() {
double total = chute(0.42, 80, new int[] {3, 0, 0});
Mesures.noter("Rafales 3,0,0 saut + chute 80 : " + total + " points");
assertEquals(0, total, 1e-9);
}
@Test
void honnete_gigueIrreguliereApresUnLag() {
// Gigue irrégulière (rafales de 3 et 4 mêlées) : mesurée à 0 point avant le correctif, doit le rester.
double total = chute(0, 90, new int[] {3, 0, 0, 4, 0, 0, 0, 1, 2, 0, 3, 0, 0});
Mesures.noter("Gigue irreguliere chute 90 : " + total + " points");
assertEquals(0, total, 1e-9);
}
@Test
void temoin_chuteRalentieUnPaquetDUnTickToutesLesTroisTicksResteVue() {
// Triche « slow fall / timer lent » : un paquet d'un tick de gravité toutes les 3 ticks serveur, sans rattrapage.
double total = chute(0, 80, new int[] {3});
Mesures.noter("Temoin chute ralentie 1/3 : " + total + " points");
assertTrue(total > 0);
}
@Test
void temoin_planeEnRafalesResteVu() {
// Plané (dy = 0) livré en rafales : doit être vu, quelle que soit la gigue.
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
double total = 0;
int[] motif = {3, 0, 0};
for (int p = 0; p < 60; p++) total += paquet(m(-0.01, motif[p % 3], false));
assertTrue(total > 0);
}
@Test
void honnete_chuteSansGigueReference() {
assertEquals(0, chute(0, 80, new int[] {1}), 1e-9);
}
}