Comparer les révisions

..
Auteur SHA1 Message Date

2026-10-16

gastineltetClaude Opus 5.5 d90e40c8b9 GastinelGarde tests : cablage NeoForge (evenements, bytecode, options, FAILLE_C4 vehicule)
CablageMinecraftTest (9 tests, sans serveur) : evenements abonnes, gardes
d'expulsion lues dans le bytecode, types d'entites C18/F20, options C7 C8
C10 C15 C18 desactivees par defaut et recopiees par GardeSpec.appliquer
(fichier charge en memoire). FAILLE_C4_apresVehicule... : vert tant que
apresVehicule ignore la marque d'expulsion (non corrige). 291 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:49 +02:00
gastineltetClaude Opus 5.5 6e208dccd2 GastinelGarde : couche Cablage testable (Garde, GardeEvents) et ses tests
Decisions du cablage Minecraft sorties sans changement de comportement :
entrees des evenements (C4 expulsion, F01, exemption manuelle), annulation
du coup, exemption contraption de la cible, C7 transition elytres, cache des
detections, position de retour (C3), sanction setback/expulsion (C2, C4)
via une interface Joueur (doublure dans les tests). Evaluation paresseuse
conservee. CablageTest : 16 tests. 266 -> 282 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 10:11:49 +02:00
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
gastineltetClaude Opus 5.5 4be81eed65 GastinelGarde config : options C10/C15 (desactivees) et marge de ping dans le toml
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:11:22 +02:00
gastineltetClaude Opus 5.5 4776895371 GastinelGarde : correctif coups-hors-boite (revue 1-4), C13, C10, C15
- revue 1 : ping > seriePingMaxMs n'exempte plus, fenetre bornee
- revue 2 / C13 : oeil suivant borne a un tick de deplacement ; regard suivant > 90 deg refuse
  par coups-hors-boite, serie de coups sauves par le regard suivant comptee en killaura-angle
- revue 3 : table SUIVIES pleine -> eviction de la cible frappee le plus anciennement
- revue 4 : fenetre selon le ping plancher des 2 dernieres minutes + 50 ms (PingPlancher)
- C10 (option volFenetreGlissante, desactivee) : fenetre glissante + sauts en l'air repetes
- C15 (options vitesseMoyenne, timerSoldeMax, desactivees) : vitesse moyenne, solde timer
Temoins modifies (a valider) : Garde92Test ping, revue 4 (cible 4,2), C13 angle en serie.
cornafserver : 254 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:11:21 +02:00
gastineltetClaude Opus 5.5 080415c646 GastinelGarde : tests revue 1-4, C10, C13, C15 inverses (CORRIGE_...), rouges avant correctif
Tests FAILLE_ inverses en CORRIGE_ ; temoins honnetes ajoutes pour C10, C15.
Stubs sans effet pour compiler : options C10/C15 (desactivees), Moteur.pingFenetre.
cornafserver (conteneur jetable) : 254 tests, 11 echecs attendus.
Le test C13 seuils passe deja : reecrit pour verifier coups-hors-boite (a valider).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 06:05:45 +02:00
27 fichiers modifiés avec 1646 ajouts et 150 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.
+160
Voir le fichier
@@ -0,0 +1,160 @@
package com.gastinelgarde;
import com.gastinelgarde.core.DetectionContraption;
import com.gastinelgarde.core.GraceTeleport;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Suivi;
import com.gastinelgarde.core.Verdict;
import java.util.List;
import java.util.UUID;
import java.util.function.BooleanSupplier;
/**
* Décisions du câblage Minecraft (Garde, GardeEvents) sorties sans changement de comportement (16/10, constat C4 ⚠️),
* pour être testées sans serveur. Aucun type Minecraft ici : Garde et GardeEvents lisent le serveur, appellent ces
* méthodes et appliquent le résultat.
*/
final class Cablage {
private Cablage() { }
// --- Entrées des événements ---
/** Ce que fait onAttaque avant toute mesure. */
enum EntreeAttaque {
/** C4 : expulsion en cours, le coup est annulé et rien n'est évalué. */
ANNULER,
/** Exemption manuelle (/garde exempter) : le coup passe sans mesure. */
IGNORER,
EVALUER
}
static EntreeAttaque entreeAttaque(boolean expulse, boolean exempteManuellement) {
if (expulse) return EntreeAttaque.ANNULER;
if (exempteManuellement) return EntreeAttaque.IGNORER;
return EntreeAttaque.EVALUER;
}
/** Fin de onAttaque : le coup est-il annulé ? (portée / hitbox ENFORCE, ou sanction ≥ SETBACK). */
static boolean annulerCoup(boolean coupsBloques, Sanction s) {
return coupsBloques || s.ordinal() >= Sanction.SETBACK.ordinal();
}
/** Fin de onAttaque : seule une EXPULSION est appliquée au joueur (un SETBACK de combat annule seulement le coup). */
static boolean appliquerApresCoup(Sanction s) {
return s == Sanction.EXPULSION;
}
/** avantMouvement : évaluer ce paquet ? (F01 thread serveur, C4 expulsion, exemption manuelle). */
static boolean evaluerAvantMouvement(boolean surThreadServeur, BooleanSupplier expulse,
BooleanSupplier exempteManuellement) {
// Paresseux : hors du thread serveur, l'état du mod n'est pas lu du tout (F01).
return surThreadServeur && !expulse.getAsBoolean() && !exempteManuellement.getAsBoolean();
}
/** apresMouvement : traiter ce paquet (état, position, traces) ? L'exemption manuelle est vue plus loin. */
static boolean traiterApresMouvement(boolean surThreadServeur, BooleanSupplier expulse) {
return surThreadServeur && !expulse.getAsBoolean();
}
/** Sanction de mouvement à appliquer (≥ SETBACK). */
static boolean sanctionDeMouvement(Sanction s) {
return s.ordinal() >= Sanction.SETBACK.ordinal();
}
// --- Exemptions contraption de la cible (portée / hitbox) ---
/**
* Portée et hitbox mesurées ? Non si la cible, ou son véhicule racine, est une contraption ou sur un vaisseau
* Sable. Évaluation paresseuse dans le même ordre que l'ancien code.
*/
static boolean mesurerPorteeHitbox(BooleanSupplier cibleContraption, BooleanSupplier cibleSable,
boolean racineEstCible, BooleanSupplier racineContraption,
BooleanSupplier racineSable) {
return !cibleContraption.getAsBoolean() && !cibleSable.getAsBoolean()
&& (racineEstCible || (!racineContraption.getAsBoolean() && !racineSable.getAsBoolean()));
}
// --- C7 : déploiement des élytres ---
/** Suivi du plané en cours : est-il commencé moins de elytresAirMinTicks après le dernier sol serveur ? */
static final class Elytres {
boolean vues;
boolean suspectes;
/** À chaque construction de l'état : transition isFallFlying. */
void observer(boolean plane, int solServeurTick, int tick, int airMinTicks) {
if (plane) {
if (!vues) {
vues = true;
suspectes = solServeurTick != Integer.MIN_VALUE && tick - solServeurTick < airMinTicks;
}
} else {
vues = false;
suspectes = false;
}
}
}
// --- Détection en cache (contraption, courant d'air) ---
/** Détection refaite au plus toutes les 10 ticks, puis grâce après la dernière détection positive. */
static final class CacheDetection {
int tick = Integer.MIN_VALUE;
int vuTick = Integer.MIN_VALUE;
boolean proche;
boolean lire(int maintenant, BooleanSupplier detecter, int graceTicks) {
if (tick == Integer.MIN_VALUE || maintenant - tick >= 10 || maintenant < tick) {
proche = detecter.getAsBoolean();
tick = maintenant;
if (proche) vuTick = maintenant;
}
return proche || DetectionContraption.dansLaGrace(maintenant, vuTick, graceTicks);
}
}
// --- Position de retour (C3) ---
/** apresMouvement : la position de ce paquet devient-elle la position de retour ? */
static boolean memoriserRetour(Moteur moteur, int dernierVerdictTick, int tick, BooleanSupplier vehiculeControle,
boolean solServeur, boolean milieuSpecial) {
return dernierVerdictTick != tick && !vehiculeControle.getAsBoolean()
&& moteur.positionDeRetourAdmise(solServeur, milieuSpecial);
}
// --- Sanctions (C2, C4) ---
/** Ce que la sanction fait au joueur réel (adaptateur ServerPlayer dans Garde, doublure dans les tests). */
interface Joueur {
UUID id();
String nom();
String dimension();
int tick();
void annoncerTeleport(GraceTeleport.Origine origine);
void teleporter(double x, double y, double z, float yaw, float pitch);
void deconnecter(String message);
void journal(String ligne);
}
/** Expulsion à usage unique (C4) ; setback vers la position de retour de la même dimension, puis remise à zéro (C2). */
static void appliquerSanction(Moteur moteur, Joueur 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.id(), p.tick() * 50L)) return;
p.journal(p.nom() + " EXPULSE (" + raison + ")");
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
} else if (s == Sanction.SETBACK) {
Suivi sv = moteur.suivi(p.id());
if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) {
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
p.teleporter(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.id(), p.tick() * 50L);
p.journal(p.nom() + " SETBACK (" + raison + ")");
}
}
}
}
+63 -45
Voir le fichier
@@ -77,13 +77,12 @@ public final class Garde {
int vehiculeTick = Integer.MIN_VALUE;
double vehiculeX, vehiculeY, vehiculeZ;
// Cache de la détection de contraption (la requête d'entités coûte plus que le reste)
int contraptionTick = Integer.MIN_VALUE;
int contraptionVuTick = Integer.MIN_VALUE;
boolean contraptionProche;
final Cablage.CacheDetection contraption = new Cablage.CacheDetection();
// C7 : dernier tick au sol (serveur) et validité du déploiement des élytres en cours
int solServeurTick = Integer.MIN_VALUE;
final Cablage.Elytres elytres = new Cablage.Elytres();
// 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;
boolean courantProche;
final Cablage.CacheDetection courant = new Cablage.CacheDetection();
// #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux)
double[] oeilDernier;
double[] oeilAvant;
@@ -240,6 +239,8 @@ public final class Garde {
SUIVIES.put(p.getId(), s);
}
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
// Revue 4 (16/10) : ping noté chaque seconde, hors combat aussi, pour le plancher de ping.
if (tick % 20 == 0) MOTEUR.pingFenetre(p.getUUID(), tick * 50L, p.connection.latency());
}
java.util.Iterator<Map.Entry<Integer, Suivie>> it = SUIVIES.entrySet().iterator();
while (it.hasNext()) {
@@ -273,7 +274,11 @@ public final class Garde {
if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return null;
Suivie s = SUIVIES.get(cible.getId());
if (s == null || s.entite != cible) {
if (!(cible instanceof Player) && SUIVIES.size() < SUIVIES_MAX) {
if (!(cible instanceof Player)) {
// Revue 3 (16/10) : table pleine, on évince la cible non joueur frappée il y a le plus longtemps
// (avant : la nouvelle cible n'était jamais suivie, faire frapper beaucoup d'entités aveuglait le
// contrôle). La cible qu'on frappe sans arrêt est la plus récente : jamais évincée.
if (s == null && SUIVIES.size() >= SUIVIES_MAX) evincerPlusAncienne();
s = new Suivie(cible);
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
SUIVIES.put(cible.getId(), s);
@@ -282,10 +287,28 @@ public final class Garde {
}
if (!(cible instanceof Player)) s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
if (s.niveau != cible.level()) return null;
int fenetre = PorteeHitbox.ticksFenetre(attaquant.connection.latency(), CONFIG);
// Revue 4 (16/10) : ping plancher des 2 dernières minutes + marge, pas le ping déclaré du moment.
int fenetre = PorteeHitbox.ticksFenetre(
MOTEUR.pingFenetre(attaquant.getUUID(), tick * 50L, attaquant.connection.latency()), CONFIG);
return s.historique.depuis(tick - fenetre);
}
/** Revue 3 : retire de la table l'entrée non joueur dont le dernier coup est le plus ancien. */
private static void evincerPlusAncienne() {
Integer cle = null;
int plusTot = Integer.MAX_VALUE;
for (Map.Entry<Integer, Suivie> e : SUIVIES.entrySet()) {
Suivie v = e.getValue();
if (v != null && v.entite instanceof Player) continue;
int t = v == null ? Integer.MIN_VALUE : v.jusquaTick;
if (cle == null || t < plusTot) {
cle = e.getKey();
plusTot = t;
}
}
if (cle != null) SUIVIES.remove(cle);
}
/** Œil de l'attaquant au paquet de mouvement d'avant le dernier (null si inconnu). */
public static double[] oeilAvant(ServerPlayer p) {
Marques m = MARQUES.get(p.getUUID());
@@ -362,12 +385,16 @@ 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.
m.elytres.observer(p.isFallFlying(), m.solServeurTick, tick, config().elytresAirMinTicks);
return EtatJoueur.builder()
.creatif(p.isCreative())
.spectateur(p.isSpectator())
.peutVoler(p.getAbilities().mayfly)
.riptide(riptideRecent)
.elytres(p.isFallFlying())
.elytresDeploiementSuspect(m.elytres.suspectes)
.levitation(p.hasEffect(MobEffects.LEVITATION))
.chuteLente(p.hasEffect(MobEffects.SLOW_FALLING))
.enVehicule(p.isPassenger())
@@ -446,12 +473,7 @@ public final class Garde {
/** La détection est refaite au plus toutes les 10 ticks par joueur ; grâce de 2 s après la dernière détection. */
private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) {
if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) {
m.contraptionProche = pocheContraption(p);
m.contraptionTick = tick;
if (m.contraptionProche) m.contraptionVuTick = tick;
}
return m.contraptionProche || DetectionContraption.dansLaGrace(tick, m.contraptionVuTick, GRACE_CONTRAPTION_TICKS);
return m.contraption.lire(tick, () -> pocheContraption(p), GRACE_CONTRAPTION_TICKS);
}
/**
@@ -546,22 +568,23 @@ 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;
// F01 : jamais depuis le thread réseau (le mixin l'évite déjà) ; C4 : expulsion en cours, plus rien à évaluer
if (!Cablage.evaluerAvantMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()),
() -> estExempteManuellement(p.getUUID()))) return;
EtatJoueur etat = etat(p, false);
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
Sanction s = traiter(p, v);
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v);
if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
}
/** 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
// C4 / C6 : ni évaluation ni état recréé après l'expulsion
if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;
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());
@@ -579,7 +602,7 @@ public final class Garde {
if (controler && em != null) {
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em);
Sanction s = traiter(p, v);
if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v);
if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v);
}
// F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup.
if (!estExempteManuellement(p.getUUID())) {
@@ -604,8 +627,8 @@ 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.
// 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())) {
if (Cablage.memoriserRetour(MOTEUR, m.dernierVerdictTick, tick, () -> vehiculeControle(p), 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());
}
@@ -825,12 +848,7 @@ public final class Garde {
/** Détection refaite au plus toutes les 10 ticks par joueur (au plus ~250 blocs lus). */
private static boolean courantAirEnCache(ServerPlayer p, Marques m, int tick) {
if (m.courantTick == Integer.MIN_VALUE || tick - m.courantTick >= 10 || tick < m.courantTick) {
m.courantProche = courantAir(p);
m.courantTick = tick;
if (m.courantProche) m.courantVuTick = tick;
}
return m.courantProche || DetectionContraption.dansLaGrace(tick, m.courantVuTick, GRACE_COURANT_TICKS);
return m.courant.lire(tick, () -> courantAir(p), GRACE_COURANT_TICKS);
}
/**
@@ -872,22 +890,22 @@ 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) {
Suivi sv = MOTEUR.suivi(p.getUUID());
String dim = p.level().dimension().location().toString();
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 + ")");
Cablage.appliquerSanction(MOTEUR, joueur(p), s, verdicts);
}
/** Adaptateur ServerPlayer de Cablage.appliquerSanction. */
private static Cablage.Joueur joueur(ServerPlayer p) {
return new Cablage.Joueur() {
@Override public UUID id() { return p.getUUID(); }
@Override public String nom() { return p.getGameProfile().getName(); }
@Override public String dimension() { return p.level().dimension().location().toString(); }
@Override public int tick() { return p.server.getTickCount(); }
@Override public void annoncerTeleport(GraceTeleport.Origine origine) { Garde.annoncerTeleport(p, origine); }
@Override public void teleporter(double x, double y, double z, float yaw, float pitch) {
p.connection.teleport(x, y, z, yaw, pitch);
}
}
@Override public void deconnecter(String message) { p.connection.disconnect(Component.literal(message)); }
@Override public void journal(String ligne) { ecrireJournal(ligne); }
};
}
}
+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,
+15 -11
Voir le fichier
@@ -57,11 +57,16 @@ 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;
switch (Cablage.entreeAttaque(Garde.moteur().estExpulse(p.getUUID()), Garde.estExempteManuellement(p.getUUID()))) {
case ANNULER -> { // C4 : expulsion en cours
event.setCanceled(true);
return;
}
case IGNORER -> {
return;
}
case EVALUER -> { }
}
if (Garde.estExempteManuellement(p.getUUID())) return;
Entity cible = event.getTarget();
int tick = p.server.getTickCount();
@@ -83,8 +88,9 @@ public final class GardeEvents {
// (le client envoie son coup avant sa rotation du même tick, voir core.CoupDiffere).
// L'angle killaura est lui aussi mesuré en différé (même retard d'un tick de la rotation), toujours.
Entity racine = cible.getRootVehicle();
boolean mesurerPH = !Garde.estContraption(cible) && !SableAcces.surSousNiveau(cible)
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine)));
boolean mesurerPH = Cablage.mesurerPorteeHitbox(() -> Garde.estContraption(cible),
() -> SableAcces.surSousNiveau(cible), racine == cible, () -> Garde.estContraption(racine),
() -> SableAcces.surSousNiveau(racine));
double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2)
+ Math.pow(cible.getZ() - cible.zo, 2));
// #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge
@@ -103,11 +109,9 @@ public final class GardeEvents {
}
Sanction s = Garde.traiter(p, verdicts);
if (Garde.moteur().coupsBloques(p.getUUID(), tick * 50L)) event.setCanceled(true); // portée / hitbox ENFORCE
if (s.ordinal() >= Sanction.SETBACK.ordinal()) {
event.setCanceled(true); // le « retour en arrière » d'un coup : il est simplement annulé
if (s == Sanction.EXPULSION) Garde.appliquerSanctionMouvement(p, s, verdicts);
}
// portée / hitbox ENFORCE ; le « retour en arrière » d'un coup (sanction ≥ SETBACK) : il est simplement annulé
if (Cablage.annulerCoup(Garde.moteur().coupsBloques(p.getUUID(), tick * 50L), s)) event.setCanceled(true);
if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts);
}
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
+39 -1
Voir le fichier
@@ -49,6 +49,14 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue TICKS_AFFICHAGE;
private static final ModConfigSpec.IntValue SERIE_PING_MAX;
private static final ModConfigSpec.IntValue SERIE_PING_MARGE;
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;
@@ -125,8 +133,10 @@ public final class GardeSpec {
"Valeurs de départ prudentes, à régler avec les journaux en OBSERVE avant tout ENFORCE.").push("coupsHorsBoite");
TICKS_AFFICHAGE = b.comment("Retard d'affichage de base de la cible chez le client (ticks) ; le ping s'ajoute (ping / 50).")
.defineInRange("ticksAffichageCible", 7, 2, 12);
SERIE_PING_MAX = b.comment("Ping (ms) au-delà duquel le coup n'est pas mesuré.")
SERIE_PING_MAX = b.comment("Ping (ms) pris en compte au plus dans la fenêtre (au-delà, le coup est mesuré avec cette fenêtre).")
.defineInRange("seriePingMaxMs", 500, 100, 500);
SERIE_PING_MARGE = b.comment("Fenêtre selon le ping le plus bas des 2 dernières minutes + cette marge (ms), pas le ping du moment.")
.defineInRange("seriePingMargeMs", 50, 0, 500);
SERIE_MANQUE = b.comment("Coup hors boîte si le regard manque toutes les boîtes vues de plus de cette marge (blocs).")
.defineInRange("serieManqueBlocs", 0.15, 0.05, 2.0);
SERIE_PORTEE = b.comment("... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs).")
@@ -140,12 +150,29 @@ public final class GardeSpec {
b.push("timer");
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
TIMER_SOLDE_MAX = b.comment("C15 : solde de paquets (reçus - ticks écoulés) au-delà duquel le timer compte (timer 1,05-1,10).",
"0 = désactivé (défaut). Essai conseillé : 20, en OBSERVE.")
.defineInRange("timerSoldeMax", 0, 0, 1000);
b.pop();
b.push("mouvement");
EXCES_VITESSE = b.comment("Total d'excès de vitesse horizontale (blocs) sur 20 ticks avant une infraction.",
"Valeurs de départ généreuses, à resserrer avec les traces réelles.")
.defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0);
VOL_FENETRE_GLISSANTE = b.comment("C10 : vol, ticks anormaux sur une fenêtre glissante et sauts en l'air répétés.",
"Désactivé par défaut : à essayer en OBSERVE (vol est en ENFORCE en production).")
.define("volFenetreGlissante", false);
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");
@@ -195,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();
@@ -248,6 +278,13 @@ public final class GardeSpec {
c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get();
c.ticksAffichageCible = TICKS_AFFICHAGE.get();
c.seriePingMaxMs = SERIE_PING_MAX.get();
c.seriePingMargeMs = SERIE_PING_MARGE.get();
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();
@@ -322,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) {
+64 -4
Voir le fichier
@@ -15,6 +15,24 @@ final class CoupDiffere {
/** Le paquet de mouvement du même tick arrive normalement juste après ; 2 ticks de marge pour la gigue. */
static final int TICKS_MAX = 2;
/**
* Revue 2 / C13 (16/10) : au-delà de cet angle entre le regard du coup et celui du paquet suivant (rotation
* silencieuse : regard ailleurs au coup, ramené sur la cible juste après), le regard suivant n'est plus pris par
* coups-hors-boite, et le coup est compté comme « sauvé par le regard suivant » pour l'angle killaura (série, voir
* {@link Suivi#regardsSauves}). Un coup isolé garde le bénéfice du doute (demi-tour honnête possible).
* [À VÉRIFIER] en jeu : 90° couvre un « flick » honnête.
*/
static final double REGARD_SUIVANT_MAX_DEGRES = 90.0;
/**
* Revue 2 / C13 : l'œil du paquet suivant est ramené à au plus un tick de déplacement de l'œil du coup :
* déplacement horizontal du tick précédent + cette marge (accélération, élan d'un saut en courant)...
*/
static final double OEIL_SUIVANT_MARGE_H = 0.4;
/** ... déplacement vertical du tick précédent + cette marge (saut : 0,42)... */
static final double OEIL_SUIVANT_MARGE_V = 0.5;
/** ... ou, sans œil précédent connu, ce déplacement (horizontal et vertical). */
static final double OEIL_SUIVANT_DEFAUT = 0.6;
final long nowMs;
final EtatJoueur etat;
final double[] boite;
@@ -34,6 +52,11 @@ final class CoupDiffere {
/** Regard au coup et au paquet suivant (null si inconnu). */
double[] regardCoup, regardSuivant;
/** Le regard du paquet suivant a été refusé (trop loin du regard du coup). */
boolean regardSuivantRefuse;
/** Excédent d'angle killaura avec le regard du coup seul (avant affinage), -1 si non mesuré. */
double excedentCoup = -1;
CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
double distance, double manque, double excedent, boolean porteeHitbox) {
this.nowMs = nowMs;
@@ -52,10 +75,18 @@ final class CoupDiffere {
return d >= 0 && d <= TICKS_MAX;
}
/** Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. */
void affiner(double[] oeil, double[] regard) {
oeilSuivant = oeil.clone();
regardSuivant = regard.clone();
/**
* Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. Revue 2 / C13 (16/10) : l'œil
* suivant est borné à un tick de déplacement depuis l'œil du coup, et le regard suivant n'est pris que s'il reste
* à moins de {@link #REGARD_SUIVANT_MAX_DEGRES} du regard du coup.
*/
void affiner(double[] oeilRecu, double[] regardRecu) {
double[] oeil = oeilCoup == null ? oeilRecu.clone() : bornerOeil(oeilCoup, oeilPrecedent, oeilRecu);
double[] regard = regardRecu.clone();
regardSuivantRefuse = regardCoup != null && !regardAdmis(regardCoup, regardRecu);
excedentCoup = excedent;
oeilSuivant = oeil;
regardSuivant = regardSuivantRefuse ? null : regard;
double[] b = boite;
double d = PorteeHitbox.distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]);
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
@@ -68,4 +99,33 @@ final class CoupDiffere {
if (a >= 0) excedent = Math.min(excedent, a);
}
}
/** Le regard suivant est-il à moins de {@link #REGARD_SUIVANT_MAX_DEGRES} du regard du coup ? */
static boolean regardAdmis(double[] coup, double[] suivant) {
double n1 = Math.sqrt(coup[0] * coup[0] + coup[1] * coup[1] + coup[2] * coup[2]);
double n2 = Math.sqrt(suivant[0] * suivant[0] + suivant[1] * suivant[1] + suivant[2] * suivant[2]);
if (n1 < 1e-9 || n2 < 1e-9) return true;
double c = (coup[0] * suivant[0] + coup[1] * suivant[1] + coup[2] * suivant[2]) / (n1 * n2);
return c >= Math.cos(Math.toRadians(REGARD_SUIVANT_MAX_DEGRES)) - 1e-9;
}
/** Œil suivant ramené à un tick de déplacement de l'œil du coup (horizontal et vertical à part). */
static double[] bornerOeil(double[] coup, double[] precedent, double[] suivant) {
double bornH, bornV;
if (precedent == null) {
bornH = OEIL_SUIVANT_DEFAUT;
bornV = OEIL_SUIVANT_DEFAUT;
} else {
bornH = Math.hypot(coup[0] - precedent[0], coup[2] - precedent[2]) + OEIL_SUIVANT_MARGE_H;
bornV = Math.abs(coup[1] - precedent[1]) + OEIL_SUIVANT_MARGE_V;
}
double dx = suivant[0] - coup[0], dz = suivant[2] - coup[2], dy = suivant[1] - coup[1];
double h = Math.hypot(dx, dz);
if (h > bornH) {
dx *= bornH / h;
dz *= bornH / h;
}
if (Math.abs(dy) > bornV) dy = Math.copySign(bornV, dy);
return new double[] {coup[0] + dx, coup[1] + dy, coup[2] + dz};
}
}
+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");
+25 -1
Voir le fichier
@@ -72,7 +72,7 @@ public final class GardeConfig {
* 3 ticks (mob), interpolation sur 3 ticks, plus 1 tick de gigue. Le ping s'ajoute (voir seriePingMaxMs).
*/
public int ticksAffichageCible = 7;
/** Ping (ms) au-delà duquel la mesure compensée n'est pas faite (fenêtre plus large que l'historique fiable). */
/** Ping (ms) pris en compte au plus dans la fenêtre (revue 1, 16/10 : au-delà, mesuré quand même, fenêtre bornée). */
public int seriePingMaxMs = 500;
/** Un coup est « hors boîte » si le regard manque toutes les boîtes vues de plus de cette marge (blocs). */
public double serieManqueBlocs = 0.15;
@@ -86,6 +86,30 @@ public final class GardeConfig {
public long serieFenetreMs = 30000;
/** Points par coup hors boîte dans une série suspecte. */
public double seriePoints = 2.0;
/**
* Revue 4 (16/10) : la fenêtre d'historique suit le ping le plus bas vu ces 2 dernières minutes, plus cette marge
* (ms), et non le ping déclaré : gonfler son ping pendant un combat n'élargit plus la fenêtre.
*/
public int seriePingMargeMs = 50;
// --- C10 / C15 (16/10) : détections supplémentaires, DÉSACTIVÉES par défaut (à valider en OBSERVE) ---
/** C10 : vol, ticks anormaux comptés sur une fenêtre glissante et sauts en l'air sans appui. */
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;
// --- Exemptions ---
public int graceTeleportTicks = 40;
+27 -8
Voir le fichier
@@ -185,12 +185,11 @@ public final class Moteur {
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
porteeJoueur + 1.0, boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
CoupDiffere c = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
if (serie) {
c.boitesVues = boitesVues;
c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone();
c.oeilCoup = oeil.clone();
c.regardCoup = regard.clone();
}
// Revue 2 / C13 : œil et regard du coup gardés dans tous les cas, pour borner ceux du paquet suivant.
c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone();
c.oeilCoup = oeil.clone();
c.regardCoup = regard.clone();
if (serie) c.boitesVues = boitesVues;
suivi(joueur).coupDiffere = c;
return verdicts;
}
@@ -222,11 +221,23 @@ public final class Moteur {
double pts = s.serie.enregistrer(c.nowMs, hors, cfg);
List<Verdict> verdicts = new ArrayList<>(1);
ajouter(verdicts, s, Controle.COUPS_HORS_BOITE, pts, c.nowMs, ex, String.format(Locale.ROOT,
"manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d",
m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal()));
"manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d%s",
m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal(),
c.regardSuivantRefuse ? ", regard suivant refuse" : ""));
return verdicts;
}
/**
* Revue 4 (16/10) : ping à utiliser pour la fenêtre d'historique de coups-hors-boite (voir
* {@link PorteeHitbox#ticksFenetre}). Note aussi le ping déclaré.
*/
public int pingFenetre(UUID joueur, long nowMs, int pingDeclare) {
Suivi s = suivi(joueur);
int plancher = s.pingPlancher.noter(nowMs, pingDeclare);
long avecMarge = (long) plancher + Math.max(0, cfg.seriePingMargeMs);
return (int) Math.max(0, Math.min(pingDeclare, avecMarge));
}
/** 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
@@ -250,6 +261,12 @@ public final class Moteur {
double seuil = cfg.angleMaxDegres * ex.facteur();
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, KillauraAngle.points(c.excedent, seuil), c.nowMs, ex,
String.format(Locale.ROOT, "excedent=%.1f deg (seuil %.0f, mesure differee)", c.excedent, seuil));
// C13 : coup « sauvé » seulement par un regard suivant à plus de 90° du regard du coup.
boolean sauve = c.regardSuivantRefuse && c.excedentCoup > seuil && !(c.excedent > seuil);
double ptsSauves = s.regardsSauves.enregistrer(c.nowMs, sauve, cfg);
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, ptsSauves, c.nowMs, ex, String.format(Locale.ROOT,
"regard ramene sur la cible au paquet suivant (excedent au coup %.1f deg), %d coups sur %d",
c.excedentCoup, s.regardsSauves.dernierCompte(), s.regardsSauves.dernierTotal()));
}
}
if (c.porteeHitbox) {
@@ -336,6 +353,7 @@ public final class Moteur {
"au sol declare sans bloc dessous pendant une chute");
}
if (vitesse) {
s.vitesse.moyenne = cfg.vitesseMoyenne; // C15, désactivé par défaut
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
ajouter(verdicts, s, Controle.VITESSE, pts, nowMs, ex,
String.format(Locale.ROOT, "dxz=%.3f max=%.3f ticks=%d base=%.3f", m.dxz(),
@@ -350,6 +368,7 @@ public final class Moteur {
if (vol && graceElytres) {
s.vol.vider(); // le paquet qui suit la grâce sert de référence
} else if (vol) {
s.vol.fenetreGlissante = cfg.volFenetreGlissante; // C10, désactivé par défaut
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()));
}
+43
Voir le fichier
@@ -0,0 +1,43 @@
package com.gastinelgarde.core;
/**
* Revue 4 (16/10/2026) : ping le plus bas vu sur les 2 dernières minutes, par tranches de 10 s.
*
* La fenêtre d'historique de coups-hors-boite suivait le ping déclaré : un client qui gonfle son ping pendant un
* combat (réponses keep-alive retardées) élargissait la fenêtre et cachait un « hitbox » ou un « reach ». Elle suit
* maintenant ce plancher (plus une marge, voir {@link GardeConfig#seriePingMargeMs}) : le ping qui monte d'un coup
* n'élargit plus rien, un ping durablement élevé (plus de 2 minutes) est de nouveau pris en compte.
*
* Coût constant : 12 tranches.
*/
final class PingPlancher {
static final long TRANCHE_MS = 10_000;
static final int TRANCHES = 12;
private final long[] tranche = new long[TRANCHES];
private final int[] min = new int[TRANCHES];
PingPlancher() {
java.util.Arrays.fill(tranche, Long.MIN_VALUE);
}
/** Note le ping déclaré et renvoie le plancher (ce ping s'il n'y a rien d'autre). */
int noter(long nowMs, int ping) {
long t = Math.floorDiv(nowMs, TRANCHE_MS);
int i = (int) Math.floorMod(t, (long) TRANCHES);
if (tranche[i] != t) {
tranche[i] = t;
min[i] = ping;
} else {
min[i] = Math.min(min[i], ping);
}
int plancher = ping;
for (int k = 0; k < TRANCHES; k++) {
if (tranche[k] != Long.MIN_VALUE && t - tranche[k] < TRANCHES && tranche[k] <= t) {
plancher = Math.min(plancher, min[k]);
}
}
return plancher;
}
}
+5 -4
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";
@@ -205,14 +205,15 @@ public final class PorteeHitbox {
/**
* Situations où la mesure compensée n'est pas fiable (en plus de {@link #raisonNonMesure}, sans la vitesse
* instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées), ping au-delà
* de {@link GardeConfig#seriePingMaxMs} (la fenêtre ne couvrirait plus le retard d'affichage).
* instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées).
*
* Revue 1 (16/10) : un ping au-delà de {@link GardeConfig#seriePingMaxMs} n'exempte plus le coup (le ping est
* falsifiable) ; la fenêtre reste bornée à ce ping par {@link #ticksFenetre}.
*/
public static String raisonNonMesureSerie(EtatJoueur e, GardeConfig cfg) {
String r = raisonNonMesure(e, 0, cfg);
if (r != null) return r;
if (e.ticksDepuisGel() <= cfg.graceGelTicks) return "gel-serveur";
if (e.pingMs() > cfg.seriePingMaxMs) return "ping";
return null;
}
}
+7
Voir le fichier
@@ -16,6 +16,13 @@ public final class Suivi {
public final VehiculeMouvement vehicule = new VehiculeMouvement();
/** #92 : derniers coups mesurés avec l'historique de la cible (contrôle coups-hors-boite). */
public final SerieCoups serie = new SerieCoups();
/** Revue 4 (16/10) : ping le plus bas des 2 dernières minutes (fenêtre de coups-hors-boite). */
final PingPlancher pingPlancher = new PingPlancher();
/**
* C13 (16/10) : derniers coups dont l'angle killaura n'était bon que grâce à un regard suivant à plus de 90° du
* regard du coup (rotation silencieuse). Mêmes réglages de série que coups-hors-boite.
*/
public final SerieCoups regardsSauves = new SerieCoups();
/** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */
CoupDiffere coupDiffere;
+31
Voir le fichier
@@ -16,7 +16,36 @@ public final class TimerPaquets {
private final CompteurTranches compteur = new CompteurTranches(TRANCHE_MS, SECONDES_MAX * TRANCHES_PAR_SECONDE + 1);
/**
* C15 (16/10) : solde de paquets (reçus - ticks écoulés), option {@link GardeConfig#timerSoldeMax} (0 = désactivé).
* Un timer à 1,09 (21,8 paquets/s) restait sous le seuil de 22 paquets/s ; son solde, lui, grandit sans fin. Le
* crédit accumulé pendant un lag (paquets en retard, puis rafale de rattrapage) est borné à {@link #CREDIT_MAX}.
*/
static final double CREDIT_MAX = 40;
private double solde;
private long dernierMs = Long.MIN_VALUE;
private double solde(long nowMs, GardeConfig cfg, double facteur) {
if (cfg.timerSoldeMax <= 0) return 0;
if (dernierMs == Long.MIN_VALUE) {
dernierMs = nowMs;
solde = 0;
return 0;
}
solde += 1.0 - Math.max(0, nowMs - dernierMs) / (double) TRANCHE_MS;
solde = Math.max(-CREDIT_MAX, solde);
dernierMs = Math.max(dernierMs, nowMs);
double max = cfg.timerSoldeMax * facteur;
if (solde <= max) return 0;
return 1.0 + Math.min(3.0, (solde - max) / 20.0);
}
public double enregistrer(long nowMs, GardeConfig cfg, double facteur) {
double ptsSolde = solde(nowMs, cfg, facteur);
return Math.max(ptsSolde, enregistrerDebit(nowMs, cfg, facteur));
}
private double enregistrerDebit(long nowMs, GardeConfig cfg, double facteur) {
compteur.ajouter(nowMs);
int max = (int) Math.floor(cfg.paquetsParSecondeMax * facteur);
int secondes = Math.min(SECONDES_MAX, Math.max(1, cfg.timerSecondesSoutenues));
@@ -31,5 +60,7 @@ public final class TimerPaquets {
public void vider() {
compteur.vider();
solde = 0;
dernierMs = Long.MIN_VALUE;
}
}
+60 -3
Voir le fichier
@@ -56,6 +56,24 @@ public final class VitesseHorizontale {
private int ticksDepuisSortie = Integer.MAX_VALUE;
private double dernierPermis;
// --- C15 (16/10) : vitesse moyenne, option {@link GardeConfig#vitesseMoyenne} désactivée par défaut ---
/** Fenêtre (paquets) sur laquelle la vitesse moyenne est comparée à la moyenne vanilla. */
public static final int MOYENNE_PAQUETS = 40;
/** Moyenne vanilla en course au sol (0,2806 bloc/tick en régime établi) et en sprint-saut (~0,356, 7,13 m/s). */
public static final double MOYENNE_COURSE_SOL = 0.29;
public static final double MOYENNE_COURSE_AIR = 0.36;
/** Marche : au sol 0,216 ; en l'air (saut en marchant) la base actuelle suffit. */
public static final double MOYENNE_MARCHE_SOL = 0.22;
/** Marge sur la moyenne attendue (arrondis, petites accélérations). [À VÉRIFIER] avec des traces réelles. */
public static final double MOYENNE_MARGE = 0.08;
/** Activé par le moteur selon la configuration. */
boolean moyenne;
private final double[] moyDxz = new double[MOYENNE_PAQUETS];
private final double[] moyAttendu = new double[MOYENNE_PAQUETS];
private int moyIndex;
private int moyRemplis;
/** Vitesse maximale attendue (blocs par tick) pour cet état, avant la tolérance du lag. */
public static double vitesseMax(EtatMouvement e) {
double v;
@@ -84,6 +102,7 @@ public final class VitesseHorizontale {
double base = vitesseMax(e) * facteur;
if (e.milieuSpecial() || e.frictionAnormale()) {
// Glace, eau, échelle… : non contrôlé, mais l'élan qui en sort est légitime.
viderMoyenne();
pousser(0);
memoriser(e.dxz(), base, TRAINEE_AIR);
avancerSortie(ticks);
@@ -105,13 +124,49 @@ public final class VitesseHorizontale {
// Un paquet = un tick du client, même arrivé après 2 ticks serveur : l'élan est son déplacement, borné par le
// permis d'UN tick (sinon un client qui n'envoie qu'un paquet sur deux se construirait un élan).
memoriser(Math.min(e.dxz(), permisParTick), base, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
boolean sortieRecente = ticksDepuisSortie < MOYENNE_PAQUETS;
avancerSortie(ticks);
double ptsMoyenne = moyenne ? moyenne(e, ticks, facteur, sortieRecente) : 0;
if (depasse <= 0) return 0;
if (depasse <= 0) return ptsMoyenne;
double total = 0;
for (double v : exces) total += v;
if (total <= seuilBlocs) return 0;
return 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0);
if (total <= seuilBlocs) return ptsMoyenne;
return Math.max(ptsMoyenne, 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0));
}
/**
* C15 (16/10) : la base en l'air (0,42 dès que le joueur court) et le tampon de 1,5 bloc sur 20 ticks laissaient
* passer un Speed à 0,37-0,40 bloc/tick sans fin. Ici, la moyenne des {@link #MOYENNE_PAQUETS} derniers paquets est
* comparée à la moyenne vanilla du même état (course au sol, sprint-saut). Pas de mesure juste après un état
* exempté (élan hérité) ni dans un milieu non contrôlé (fenêtre vidée).
*/
private double moyenne(EtatMouvement e, int ticks, double facteur, boolean sortieRecente) {
if (sortieRecente) {
viderMoyenne();
return 0;
}
double base = vitesseMax(e);
double brut;
if (e.furtif() || e.ralentiParObjet()) brut = base; // pas de moyenne connue : la borne actuelle
else if (e.sprint()) brut = base * (e.auSolServeur() ? MOYENNE_COURSE_SOL / COURSE : MOYENNE_COURSE_AIR / COURSE_SAUT);
else brut = e.auSolServeur() ? base * MOYENNE_MARCHE_SOL / MARCHE : base;
moyDxz[moyIndex] = e.dxz();
moyAttendu[moyIndex] = brut * facteur * ticks;
moyIndex = (moyIndex + 1) % MOYENNE_PAQUETS;
if (moyRemplis < MOYENNE_PAQUETS) moyRemplis++;
if (moyRemplis < MOYENNE_PAQUETS) return 0;
double d = 0, a = 0;
for (int i = 0; i < MOYENNE_PAQUETS; i++) {
d += moyDxz[i];
a += moyAttendu[i];
}
return d > a * (1.0 + MOYENNE_MARGE) ? 0.5 : 0;
}
private void viderMoyenne() {
moyIndex = 0;
moyRemplis = 0;
}
/**
@@ -125,6 +180,7 @@ public final class VitesseHorizontale {
public void exempter(EtatMouvement e, double facteur, boolean sortieDEtat) {
java.util.Arrays.fill(exces, 0);
index = 0;
viderMoyenne();
int ticks = Math.max(1, e.ticks());
memoriser(e.dxz(), vitesseMax(e) * facteur, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
if (sortieDEtat) ticksDepuisSortie = 0;
@@ -161,5 +217,6 @@ public final class VitesseHorizontale {
aElan = false;
elan = 0;
ticksDepuisSortie = Integer.MAX_VALUE;
viderMoyenne();
}
}
+76 -1
Voir le fichier
@@ -19,6 +19,33 @@ 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;
/** Plus de ticks anormaux que ça dans la fenêtre : infraction (alterner 1 anormal / 1 normal en donne 10). */
public static final int FENETRE_ANORMAUX_MAX = 8;
/** Un « saut en l'air » : montée d'au moins ça (blocs) au-dessus de la prévision de gravité, sans appui. */
public static final double SAUT_EN_L_AIR_MIN = 0.2;
/** Deux sauts en l'air à moins de ce nombre de ticks en l'air l'un de l'autre : infraction. */
public static final int SAUTS_FENETRE_TICKS = 60;
/** Activé par le moteur selon la configuration. */
boolean fenetreGlissante;
private final boolean[] fenetre = new boolean[FENETRE_TICKS];
private int fenetreIndex;
private int fenetreAnormaux;
private int ticksEnAir;
private int dernierSautEnAir = Integer.MIN_VALUE;
/** Au-delà, l'écart entre deux paquets est trop grand pour prédire (lag) : on oublie la vitesse. */
public static final int TICKS_MAX = 40;
@@ -35,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();
@@ -44,27 +72,38 @@ 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;
double sommeMax = -Double.MAX_VALUE; // la prévision la plus haute parmi les ticks candidats
for (int k = 1; k <= kMax; k++) {
v = (v - GRAVITE) * TRAINEE;
somme += v;
if (k >= kMin) sommeMax = Math.max(sommeMax, somme);
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);
if (anormauxConsecutifs > TICKS_ANORMAUX) {
points = 1.0 + Math.min(3.0, (anormauxConsecutifs - TICKS_ANORMAUX) / 10.0);
}
if (fenetreGlissante) {
points = Math.max(points, fenetreGlissante(ecart, dy, sommeMax, Math.max(1, n)));
}
}
derniereVitesse = vitesseFin;
@@ -73,10 +112,46 @@ public final class VolVertical {
return points;
}
/**
* C10 (16/10) : le compteur de ticks anormaux consécutifs redescend d'un cran à chaque tick normal ; un saut en
* l'air tous les 10 ticks, ou l'alternance d'un tick plané et d'un tick de gravité, ne l'atteignaient jamais.
* En plus : ticks anormaux comptés sur une fenêtre glissante, et tout gain d'altitude franc en l'air (sans sol,
* hors exemptions : recul, téléportation, milieux spéciaux) compté comme un saut en l'air ; le deuxième à moins
* de {@link #SAUTS_FENETRE_TICKS} ticks en l'air du précédent est une infraction.
*/
private double fenetreGlissante(boolean ecart, double dy, double prevision, int ticks) {
ticksEnAir += ticks;
if (fenetre[fenetreIndex]) fenetreAnormaux--;
fenetre[fenetreIndex] = ecart;
if (ecart) fenetreAnormaux++;
fenetreIndex = (fenetreIndex + 1) % FENETRE_TICKS;
double points = 0;
if (fenetreAnormaux > FENETRE_ANORMAUX_MAX) {
points = 1.0 + Math.min(3.0, (fenetreAnormaux - FENETRE_ANORMAUX_MAX) / 4.0);
}
if (ecart && dy > 0 && dy - prevision >= SAUT_EN_L_AIR_MIN) {
if (dernierSautEnAir != Integer.MIN_VALUE && ticksEnAir - dernierSautEnAir <= SAUTS_FENETRE_TICKS) {
points = Math.max(points, 2.0);
}
dernierSautEnAir = ticksEnAir;
}
return points;
}
private void viderFenetre() {
java.util.Arrays.fill(fenetre, false);
fenetreIndex = 0;
fenetreAnormaux = 0;
ticksEnAir = 0;
dernierSautEnAir = Integer.MIN_VALUE;
}
public void vider() {
derniereVitesse = 0;
aVitesse = false;
etaitEnAir = false;
anormauxConsecutifs = 0;
avance = 0;
viderFenetre();
}
}
+6 -8
Voir le fichier
@@ -16,8 +16,8 @@ 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 à
* Corrigé le 16/10 (branche fix/hitbox-c10-c13-c15) : quand la table est pleine, la cible non joueur suivie dont le
* dernier coup est le plus ancien est évincée au profit de la nouvelle (avant : la nouvelle n'était jamais suivie). 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é
@@ -28,7 +28,7 @@ class AutotestSuiviesTest {
@SuppressWarnings("unchecked")
@Test
void FAILLE_revue3_tablePleineLesNouvellesCiblesNeSontJamaisSuivies() throws Exception {
void CORRIGE_revue3_tablePleineLaNouvelleCibleEvinceLaPlusAncienne() throws Exception {
Field fTable = Garde.class.getDeclaredField("SUIVIES");
fTable.setAccessible(true);
Map<Integer, Object> table = (Map<Integer, Object>) fTable.get(null);
@@ -52,11 +52,9 @@ class AutotestSuiviesTest {
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");
assertNull(Garde.boitesVues(cible, null, 1000), "premier coup : historique incomplet");
assertTrue(table.containsKey(cible.getId()), "corrigé : table pleine, la cible est quand même suivie");
assertEquals(max, table.size(), "une entrée évincée, la table ne grandit pas");
} finally {
table.clear();
}
+336
Voir le fichier
@@ -0,0 +1,336 @@
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.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.GardeConfig;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.Set;
import net.neoforged.neoforge.common.ModConfigSpec;
import org.junit.jupiter.api.Assumptions;
import org.junit.jupiter.api.Test;
import org.objectweb.asm.ClassReader;
import org.objectweb.asm.tree.AbstractInsnNode;
import org.objectweb.asm.tree.ClassNode;
import org.objectweb.asm.tree.InvokeDynamicInsnNode;
import org.objectweb.asm.tree.MethodInsnNode;
import org.objectweb.asm.tree.MethodNode;
/**
* Câblage Minecraft (constat C4 ⚠️), partie qui demande les classes du jeu mais pas de serveur : événements
* NeoForge abonnés, gardes d'expulsion lues dans le bytecode, types d'entités (C18, F20), options (C7, C8, C10, C15,
* C18) du fichier toml jusqu'à la configuration du moteur.
*/
class CablageMinecraftTest {
// --- Bytecode ---
private static ClassNode lire(Class<?> c) throws Exception {
try (InputStream in = c.getResourceAsStream("/" + c.getName().replace('.', '/') + ".class")) {
assertNotNull(in, c.getName());
ClassNode n = new ClassNode();
new ClassReader(in).accept(n, 0);
return n;
}
}
/** Méthodes appelées par une méthode et par ses lambdas (récursivement, dans la même classe). */
private static Set<String> appels(ClassNode classe, String methode) {
Set<String> sortie = new HashSet<>();
Set<String> vues = new HashSet<>();
parcourir(classe, methode, sortie, vues);
return sortie;
}
private static void parcourir(ClassNode classe, String methode, Set<String> sortie, Set<String> vues) {
if (!vues.add(methode)) return;
boolean trouvee = false;
for (MethodNode m : classe.methods) {
if (!m.name.equals(methode)) continue;
trouvee = true;
for (AbstractInsnNode i : m.instructions) {
if (i instanceof MethodInsnNode mi) {
sortie.add(mi.owner.substring(mi.owner.lastIndexOf('/') + 1) + "." + mi.name);
} else if (i instanceof InvokeDynamicInsnNode d) {
for (Object a : d.bsmArgs) {
if (a instanceof org.objectweb.asm.Handle h && h.getOwner().equals(classe.name)) {
parcourir(classe, h.getName(), sortie, vues);
} else if (a instanceof org.objectweb.asm.Handle h) {
sortie.add(h.getOwner().substring(h.getOwner().lastIndexOf('/') + 1) + "." + h.getName());
}
}
}
}
}
assertTrue(trouvee, methode);
}
@Test
void C4_lesPointsDEntreeConsultentLaMarqueDExpulsion() throws Exception {
ClassNode garde = lire(Garde.class);
ClassNode events = lire(GardeEvents.class);
assertTrue(appels(garde, "avantMouvement").contains("Moteur.estExpulse"));
assertTrue(appels(garde, "avantMouvement").contains("Cablage.evaluerAvantMouvement"));
assertTrue(appels(garde, "apresMouvement").contains("Moteur.estExpulse"));
assertTrue(appels(garde, "apresMouvement").contains("Cablage.traiterApresMouvement"));
assertTrue(appels(events, "onAttaque").contains("Moteur.estExpulse"));
assertTrue(appels(events, "onAttaque").contains("Cablage.entreeAttaque"));
assertTrue(appels(events, "onConnexion").contains("Moteur.oublierExpulsion"), "reconnexion : marque effacée");
assertFalse(appels(events, "onDeconnexion").contains("Moteur.oublierExpulsion"),
"la marque survit à la déconnexion (C6)");
assertTrue(appels(garde, "appliquerSanctionMouvement").contains("Cablage.appliquerSanction"));
Set<String> sanction = appels(lire(Cablage.class), "appliquerSanction");
assertTrue(sanction.contains("Moteur.expulser"));
assertTrue(sanction.contains("Moteur.apresSetback"));
assertFalse(appels(garde, "appliquerSanctionMouvement").stream().anyMatch(a -> a.toLowerCase().contains("ban")),
"jamais de bannissement");
}
/**
* FAILLE (16/10, trouvée en écrivant ces tests) : apresVehicule ne regarde pas la marque d'expulsion, à la
* différence de avantMouvement / apresMouvement / onAttaque. Un paquet de véhicule traité après l'expulsion
* (même lot de paquets, avant la fermeture de la connexion) est encore évalué : journal, alerte aux ops,
* stopRiding + setback, et l'état du moteur (Suivi) est recréé. L'expulsion elle-même reste unique
* (Moteur.expulser). Ce test est vert tant que le défaut existe. Proposition : en tête d'apresVehicule,
* {@code if (!Cablage.traiterApresMouvement(surThreadServeur(p), () -> MOTEUR.estExpulse(p.getUUID()))) return;}
* (même garde, et idem pour auSolPourChute, qui peut encore appeler le moteur). Non corrigé : décision de Théo.
*/
@Test
void FAILLE_C4_apresVehiculeNeConsultePasLaMarqueDExpulsion() throws Exception {
ClassNode garde = lire(Garde.class);
Set<String> a = appels(garde, "apresVehicule");
assertTrue(a.contains("Moteur.vehicule"), "le paquet de véhicule est bien évalué par le moteur");
assertFalse(a.contains("Moteur.estExpulse"), "défaut corrigé : inverser en CORRIGE_");
assertFalse(appels(garde, "auSolPourChute").contains("Moteur.estExpulse"));
}
// --- Événements NeoForge abonnés ---
@Test
void evenementsAbonnes() {
Set<Class<?>> ev = new HashSet<>();
for (Method m : GardeEvents.class.getDeclaredMethods()) {
if (m.isAnnotationPresent(net.neoforged.bus.api.SubscribeEvent.class)) {
assertEquals(1, m.getParameterCount(), m.getName());
assertTrue(java.lang.reflect.Modifier.isStatic(m.getModifiers()), m.getName());
ev.add(m.getParameterTypes()[0]);
}
}
for (Class<?> c : new Class<?>[] {
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedInEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerLoggedOutEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerChangedDimensionEvent.class,
net.neoforged.neoforge.event.entity.player.PlayerEvent.PlayerRespawnEvent.class,
net.neoforged.neoforge.event.tick.ServerTickEvent.Pre.class,
net.neoforged.neoforge.event.tick.ServerTickEvent.Post.class,
net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent.Stop.class,
net.neoforged.neoforge.event.server.ServerStartingEvent.class,
net.neoforged.neoforge.event.server.ServerStoppedEvent.class}) {
assertTrue(ev.contains(c), c.getName());
}
assertTrue(net.neoforged.bus.api.ICancellableEvent.class.isAssignableFrom(
net.neoforged.neoforge.event.entity.player.AttackEntityEvent.class), "un coup peut être annulé");
}
@Test
void lesFauxJoueursNeSontJamaisControles() {
// GardeEvents filtre « p instanceof FakePlayer » : un FakePlayer est un ServerPlayer.
assertTrue(net.minecraft.server.level.ServerPlayer.class.isAssignableFrom(
net.neoforged.neoforge.common.util.FakePlayer.class));
}
// --- Types d'entités (C18 GardeAntiCrash, F20 vehiculeControle / etatVehicule) ---
@Test
void C18_seulsLesMinecartsContenantsSontGardesImmobiles() {
Class<?> container = net.minecraft.world.Container.class;
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartChest.class));
assertTrue(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartHopper.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.Minecart.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartTNT.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartFurnace.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartSpawner.class));
assertFalse(container.isAssignableFrom(net.minecraft.world.entity.vehicle.MinecartCommandBlock.class));
}
@Test
void F20_vehiculesControles() {
Class<?> bateau = net.minecraft.world.entity.vehicle.Boat.class;
Class<?> monture = net.minecraft.world.entity.LivingEntity.class;
assertTrue(bateau.isAssignableFrom(net.minecraft.world.entity.vehicle.ChestBoat.class), "bateau à coffre, radeau");
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.horse.Horse.class));
assertTrue(monture.isAssignableFrom(net.minecraft.world.entity.animal.Pig.class));
Class<?> minecart = net.minecraft.world.entity.vehicle.AbstractMinecart.class;
assertFalse(bateau.isAssignableFrom(minecart) || monture.isAssignableFrom(minecart),
"minecart : non contrôlé (type AUTRE), la position de retour suit le joueur");
}
// --- Options : du fichier toml au moteur ---
private static Object valeur(String champ) throws Exception {
Field f = GardeSpec.class.getDeclaredField(champ);
f.setAccessible(true);
return f.get(null);
}
@SuppressWarnings("unchecked")
private static <T> T defaut(String champ) throws Exception {
return ((ModConfigSpec.ConfigValue<T>) valeur(champ)).getDefault();
}
@Test
void optionsDesactiveesParDefautDansLeFichierEtLeMoteur() throws Exception {
GardeConfig c = new GardeConfig();
assertEquals(false, defaut("ELYTRES_STRICTE"));
assertEquals(c.elytresExemptionStricte, defaut("ELYTRES_STRICTE"));
assertEquals(2, (int) defaut("ELYTRES_AIR_MIN"));
assertEquals(c.elytresAirMinTicks, (int) defaut("ELYTRES_AIR_MIN"));
assertEquals(false, defaut("COMBAT_VEHICULE"));
assertEquals(c.combatMesureEnVehicule, defaut("COMBAT_VEHICULE"));
assertEquals(false, defaut("VOL_FENETRE_GLISSANTE"));
assertEquals(c.volFenetreGlissante, defaut("VOL_FENETRE_GLISSANTE"));
assertEquals(false, defaut("VITESSE_MOYENNE"));
assertEquals(c.vitesseMoyenne, defaut("VITESSE_MOYENNE"));
assertEquals(0, (int) defaut("TIMER_SOLDE_MAX"));
assertEquals(c.timerSoldeMax, (int) defaut("TIMER_SOLDE_MAX"));
assertEquals(c.seriePingMargeMs, (int) defaut("SERIE_PING_MARGE"));
assertEquals(false, defaut("AC_EMPILEMENT_MOUVEMENT"));
assertFalse(new com.gastinelgarde.core.AntiCrashEntites.Reglages().empilementSeulementEnMouvement);
assertFalse(GardeSpec.antiCrash().empilementSeulementEnMouvement, "fichier non chargé : défaut");
}
@Test
void laConfigProposeeNActivePasLesNouvellesOptions() throws Exception {
// Les tests tournent dans build/minecraft-junit : on remonte jusqu'à la racine du projet.
Path toml = null;
for (Path d = Path.of("").toAbsolutePath(); d != null && toml == null; d = d.getParent()) {
Path f = d.resolve("config-proposee").resolve("gastinelgarde-server.toml");
if (Files.exists(f)) toml = f;
}
Assumptions.assumeTrue(toml != null, "config-proposee introuvable depuis " + Path.of("").toAbsolutePath());
String t = Files.readString(toml, StandardCharsets.UTF_8);
for (String cle : new String[] {"elytresExemptionStricte", "combatMesureEnVehicule", "volFenetreGlissante",
"vitesseMoyenne", "empilementSeulementEnMouvement"}) {
assertFalse(t.matches("(?s).*\\b" + cle + "\\s*=\\s*true.*"), cle);
}
assertFalse(t.matches("(?s).*\\btimerSoldeMax\\s*=\\s*[1-9].*"), "timerSoldeMax");
}
/**
* GardeSpec.appliquer recopie bien chaque option dans GardeConfig. On charge le fichier en mémoire
* (ModConfigSpec.acceptConfig, par réflexion : signature propre à NeoForge 21.1), puis on le décharge.
*/
@Test
void appliquerRecopieLesOptionsDuFichier() throws Exception {
Object charge = chargerEnMemoire();
Assumptions.assumeTrue(charge != null, "[À VÉRIFIER] chargement en mémoire du ModConfigSpec impossible ici");
try {
assertTrue(GardeSpec.SPEC.isLoaded());
GardeConfig vide = new GardeConfig();
GardeSpec.appliquer(vide);
assertFalse(vide.elytresExemptionStricte);
assertFalse(vide.combatMesureEnVehicule);
assertFalse(vide.volFenetreGlissante);
assertFalse(vide.vitesseMoyenne);
assertEquals(0, vide.timerSoldeMax);
for (com.gastinelgarde.core.Controle k : com.gastinelgarde.core.Controle.values()) {
assertEquals(new GardeConfig().mode(k), vide.mode(k), "mode par défaut inchangé : " + k);
}
((ModConfigSpec.BooleanValue) valeur("ELYTRES_STRICTE")).set(true);
((ModConfigSpec.IntValue) valeur("ELYTRES_AIR_MIN")).set(5);
((ModConfigSpec.BooleanValue) valeur("COMBAT_VEHICULE")).set(true);
((ModConfigSpec.BooleanValue) valeur("VOL_FENETRE_GLISSANTE")).set(true);
((ModConfigSpec.BooleanValue) valeur("VITESSE_MOYENNE")).set(true);
((ModConfigSpec.IntValue) valeur("TIMER_SOLDE_MAX")).set(20);
GardeConfig c = new GardeConfig();
GardeSpec.appliquer(c);
assertTrue(c.elytresExemptionStricte, "C7");
assertEquals(5, c.elytresAirMinTicks, "C7");
assertTrue(c.combatMesureEnVehicule, "C8");
assertTrue(c.volFenetreGlissante, "C10");
assertTrue(c.vitesseMoyenne, "C15");
assertEquals(20, c.timerSoldeMax, "C15");
} finally {
dechargerEnMemoire();
}
assertFalse(GardeSpec.SPEC.isLoaded(), "les autres tests attendent un fichier non chargé");
}
/** null si l'API n'est pas celle attendue (le test est alors ignoré, pas faux). */
private static Object chargerEnMemoire() {
try {
Method accept = null;
for (Method m : ModConfigSpec.class.getMethods()) {
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) accept = m;
}
if (accept == null) return null;
Class<?> type = accept.getParameterTypes()[0];
com.electronwill.nightconfig.core.CommentedConfig cc =
com.electronwill.nightconfig.core.CommentedConfig.inMemory();
// Fichier déjà corrigé (valeurs par défaut) : acceptConfig n'a rien à sauvegarder.
for (Method m : ModConfigSpec.class.getMethods()) {
if (m.getName().equals("correct") && m.getParameterCount() == 1
&& m.getParameterTypes()[0].isInstance(cc)) {
m.invoke(GardeSpec.SPEC, cc);
break;
}
}
Object config = null;
if (type.isInstance(cc)) {
config = cc;
} else if (type.isSealed()) {
// NeoForge 21.1 : IConfigSpec.ILoadedConfig est scellée, seule implémentation LoadedConfig.
for (Class<?> impl : type.getPermittedSubclasses()) {
for (java.lang.reflect.Constructor<?> k : impl.getDeclaredConstructors()) {
Class<?>[] p = k.getParameterTypes();
if (p.length == 0 || !p[0].isInstance(cc)) continue;
Object[] args = new Object[p.length];
args[0] = cc;
k.setAccessible(true);
config = k.newInstance(args);
break;
}
if (config != null) break;
}
} else if (type.isInterface()) {
config = Proxy.newProxyInstance(type.getClassLoader(), new Class<?>[] {type}, (o, m, a) -> switch (m.getName()) {
case "config" -> cc;
case "hashCode" -> System.identityHashCode(o);
case "equals" -> o == a[0];
case "toString" -> "config-en-memoire";
default -> null;
});
}
if (config == null) return null;
accept.invoke(GardeSpec.SPEC, config);
return GardeSpec.SPEC.isLoaded() ? config : null;
} catch (ReflectiveOperationException | RuntimeException | LinkageError e) {
System.out.println("[CablageMinecraftTest] chargement en mémoire impossible : " + e);
dechargerEnMemoire();
return null;
}
}
private static void dechargerEnMemoire() {
try {
for (Method m : ModConfigSpec.class.getMethods()) {
if (m.getName().equals("acceptConfig") && m.getParameterCount() == 1) {
m.invoke(GardeSpec.SPEC, new Object[] {null});
}
}
} catch (ReflectiveOperationException | RuntimeException e) {
System.out.println("[CablageMinecraftTest] déchargement : " + e);
}
}
}
+300
Voir le fichier
@@ -0,0 +1,300 @@
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.assertTrue;
import com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.Exemptions;
import com.gastinelgarde.core.GardeConfig;
import com.gastinelgarde.core.GraceTeleport;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Verdict;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.BooleanSupplier;
import org.junit.jupiter.api.Test;
/**
* Câblage Minecraft (constat C4 ⚠️) : décisions de Garde / GardeEvents sorties dans {@link Cablage}, testées sans
* serveur avec une doublure du joueur et un vrai {@link Moteur}.
*/
class CablageTest {
private static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
private static final String MONDE = "minecraft:overworld";
/** Doublure de ServerPlayer : enregistre ce que la sanction lui fait, dans l'ordre. */
static final class FauxJoueur implements Cablage.Joueur {
final List<String> actions = new ArrayList<>();
String dimension = MONDE;
int tick = 1000;
@Override public UUID id() { return ID; }
@Override public String nom() { return "Tricheur"; }
@Override public String dimension() { return dimension; }
@Override public int tick() { return tick; }
@Override public void annoncerTeleport(GraceTeleport.Origine o) { actions.add("annonce " + o); }
@Override public void teleporter(double x, double y, double z, float yaw, float pitch) {
actions.add(String.format(java.util.Locale.ROOT, "teleport %.1f %.1f %.1f %.0f %.0f", x, y, z, yaw, pitch));
}
@Override public void deconnecter(String message) { actions.add("deconnexion " + message); }
@Override public void journal(String ligne) { actions.add("journal " + ligne); }
long compte(String prefixe) {
return actions.stream().filter(a -> a.startsWith(prefixe)).count();
}
}
private static Verdict verdict(Controle c, Sanction s) {
return new Verdict(c, Mode.ENFORCE, 5, 50, s, s, false, "", List.of());
}
private static BooleanSupplier compteur(AtomicInteger n, boolean valeur) {
return () -> {
n.incrementAndGet();
return valeur;
};
}
// --- Expulsion unique (C4) ---
@Test
void C4_expulsionUneSeuleFoisPuisDeNouveauApresReconnexion() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.EXPULSION));
for (int i = 0; i < 344; i++) { // incident du 15/10 : 344 disconnect en 18 s
p.tick++;
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v);
}
assertEquals(1, p.compte("deconnexion"), p.actions.toString());
assertEquals(1, p.compte("journal"));
assertEquals("journal Tricheur EXPULSE (vol)", p.actions.get(0)); // journal avant la déconnexion
assertEquals("deconnexion Expulsé par l'anti-triche (vol).", p.actions.get(1));
assertTrue(moteur.estExpulse(ID));
// GardeEvents.onConnexion : oublierExpulsion, la prochaine expulsion est de nouveau possible.
moteur.oublierExpulsion(ID);
assertFalse(moteur.estExpulse(ID));
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, v);
assertEquals(2, p.compte("deconnexion"));
}
@Test
void C4_apresLExpulsionPlusAucuneEvaluationNiCoup() {
assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, false));
assertEquals(Cablage.EntreeAttaque.ANNULER, Cablage.entreeAttaque(true, true)); // l'expulsion passe avant
assertEquals(Cablage.EntreeAttaque.IGNORER, Cablage.entreeAttaque(false, true));
assertEquals(Cablage.EntreeAttaque.EVALUER, Cablage.entreeAttaque(false, false));
AtomicInteger lus = new AtomicInteger();
assertFalse(Cablage.evaluerAvantMouvement(true, () -> true, compteur(lus, false)));
assertEquals(0, lus.get(), "expulsé : l'exemption n'est même pas lue");
assertFalse(Cablage.evaluerAvantMouvement(true, () -> false, () -> true)); // exemption manuelle
assertTrue(Cablage.evaluerAvantMouvement(true, () -> false, () -> false));
assertFalse(Cablage.traiterApresMouvement(true, () -> true));
assertTrue(Cablage.traiterApresMouvement(true, () -> false));
}
@Test
void F01_horsDuThreadServeurLEtatDuModNEstPasLu() {
AtomicInteger lus = new AtomicInteger();
assertFalse(Cablage.evaluerAvantMouvement(false, compteur(lus, false), compteur(lus, false)));
assertFalse(Cablage.traiterApresMouvement(false, compteur(lus, false)));
assertEquals(0, lus.get());
}
@Test
void expulsionSansVerdictRaisonParDefaut() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, List.of());
assertEquals("journal Tricheur EXPULSE (anti-triche)", p.actions.get(0));
}
// --- Setback (C2, C3) ---
@Test
void C2_setbackVersLaPositionAuSolPuisRemiseAZeroDuVol() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
long ms = p.tick * 50L;
moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE);
moteur.suivi(ID).vl.ajouter(Controle.VOL, 30, ms);
moteur.suivi(ID).vl.ajouter(Controle.VITESSE, 20, ms);
moteur.suivi(ID).vl.ajouter(Controle.KILLAURA_CIBLES, 7, ms);
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(List.of("annonce SETBACK", "teleport 10.5 64.0 -3.5 90 10", "journal Tricheur SETBACK (vol)"),
p.actions, "la grâce est annoncée avant le teleport (F05)");
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VOL, ms), 1e-9);
assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.VITESSE, ms), 1e-9);
assertTrue(moteur.suivi(ID).vl.valeur(Controle.KILLAURA_CIBLES, ms) > 6.9, "les autres VL ne sont pas touchées");
assertFalse(moteur.estExpulse(ID));
}
@Test
void setbackSansPositionOuAutreDimensionNeFaitRien() {
Moteur moteur = new Moteur(new GardeConfig());
FauxJoueur p = new FauxJoueur();
List<Verdict> v = List.of(verdict(Controle.VOL, Sanction.SETBACK));
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
assertTrue(p.actions.isEmpty(), "aucune position de retour : rien");
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether");
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, v);
assertTrue(p.actions.isEmpty(), "position dans une autre dimension : jamais de teleport inter-dimension");
}
@Test
void sanctionsInferieuresAuSetbackNeTouchentPasLeJoueur() {
Moteur moteur = new Moteur(new GardeConfig());
moteur.suivi(ID).memoriserPosition(0, 70, 0, 0, 0, MONDE);
FauxJoueur p = new FauxJoueur();
for (Sanction s : new Sanction[] {Sanction.AUCUNE, Sanction.JOURNAL, Sanction.ALERTE}) {
Cablage.appliquerSanction(moteur, p, s, List.of(verdict(Controle.VOL, s)));
assertFalse(Cablage.sanctionDeMouvement(s), s.name());
}
assertTrue(p.actions.isEmpty());
assertTrue(Cablage.sanctionDeMouvement(Sanction.SETBACK));
assertTrue(Cablage.sanctionDeMouvement(Sanction.EXPULSION));
}
@Test
void C3_positionDeRetourSeulementAuSolEtSansVerdictNiVehicule() {
Moteur moteur = new Moteur(new GardeConfig());
int tick = 500;
assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, true, false));
assertTrue(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, true), "eau, échelle…");
assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> false, false, false), "en l'air");
assertFalse(Cablage.memoriserRetour(moteur, tick - 1, tick, () -> true, true, false), "véhicule contrôlé");
AtomicInteger lus = new AtomicInteger();
assertFalse(Cablage.memoriserRetour(moteur, tick, tick, compteur(lus, false), true, false), "verdict ce tick");
assertEquals(0, lus.get(), "le véhicule n'est pas lu si un verdict est tombé à ce tick");
}
// --- Coups (GardeEvents.onAttaque) ---
@Test
void coupAnnuleEnEnforceOuSurSanctionEtExpulsionSeuleAppliquee() {
for (Sanction s : Sanction.values()) {
boolean grave = s.ordinal() >= Sanction.SETBACK.ordinal();
assertEquals(grave, Cablage.annulerCoup(false, s), s.name());
assertTrue(Cablage.annulerCoup(true, s), "portée / hitbox ENFORCE : " + s);
assertEquals(s == Sanction.EXPULSION, Cablage.appliquerApresCoup(s), "pas de setback sur un coup : " + s);
}
}
@Test
void cibleSurContraptionOuVaisseauPasDeMesurePorteeHitbox() {
BooleanSupplier oui = () -> true;
BooleanSupplier non = () -> false;
assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, non, non));
assertFalse(Cablage.mesurerPorteeHitbox(oui, non, true, non, non), "cible contraption");
assertFalse(Cablage.mesurerPorteeHitbox(non, oui, true, non, non), "cible sur vaisseau Sable");
assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, oui, non), "assise sur un siège Create");
assertFalse(Cablage.mesurerPorteeHitbox(non, non, false, non, oui), "véhicule sur un vaisseau");
assertTrue(Cablage.mesurerPorteeHitbox(non, non, false, non, non), "cheval, bateau : mesuré");
AtomicInteger lus = new AtomicInteger();
assertTrue(Cablage.mesurerPorteeHitbox(non, non, true, compteur(lus, true), compteur(lus, true)));
assertEquals(0, lus.get(), "sans véhicule, la racine n'est pas interrogée");
}
// --- C7 : élytres ---
@Test
void C7_deploiementTropTotApresLeSolEstSuspectPourTouteLaDureeDuPlane() {
Cablage.Elytres e = new Cablage.Elytres();
int sol = 100;
e.observer(false, sol, 100, 2);
e.observer(true, sol, 101, 2); // 1 tick après le sol (onGround falsifié)
assertTrue(e.suspectes);
for (int t = 102; t < 300; t++) e.observer(true, sol, t, 2);
assertTrue(e.suspectes, "reste suspect jusqu'à la fin du plané");
e.observer(false, sol, 300, 2);
assertFalse(e.suspectes);
assertFalse(e.vues);
Cablage.Elytres h = new Cablage.Elytres();
h.observer(true, sol, 102, 2); // 2 ticks en l'air : honnête
assertFalse(h.suspectes);
Cablage.Elytres jamais = new Cablage.Elytres();
jamais.observer(true, Integer.MIN_VALUE, 5, 2); // jamais vu au sol (connexion en plein vol)
assertFalse(jamais.suspectes);
}
@Test
void C7_unSolServeurVuPendantLePlaneNeRendPasSuspectApresCoup() {
Cablage.Elytres e = new Cablage.Elytres();
e.observer(true, 100, 120, 2);
assertFalse(e.suspectes);
e.observer(true, 125, 125, 2); // frôle un bloc en plané
assertFalse(e.suspectes, "seul le début du plané compte");
}
@Test
void C7_cableJusquAuxExemptions_avecEtSansOption() {
Cablage.Elytres e = new Cablage.Elytres();
e.observer(true, 100, 101, 2);
EtatJoueur etat = EtatJoueur.builder().elytres(true).elytresDeploiementSuspect(e.suspectes).build();
GardeConfig defaut = new GardeConfig();
assertFalse(defaut.elytresExemptionStricte, "option désactivée par défaut");
assertTrue(Exemptions.evaluer(etat, defaut, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres"));
GardeConfig stricte = new GardeConfig();
stricte.elytresExemptionStricte = true;
assertFalse(Exemptions.evaluer(etat, stricte, Exemptions.Famille.MOUVEMENT).raisons().contains("elytres"));
}
// --- C8 : combat en véhicule ---
@Test
void C8_passagerMesureSeulementAvecLOptionEtContraptionToujoursExemptee() {
EtatJoueur cheval = EtatJoueur.builder().enVehicule(true).build();
EtatJoueur siege = EtatJoueur.builder().enVehicule(true).pocheContraption(true).build();
GardeConfig defaut = new GardeConfig();
assertFalse(defaut.combatMesureEnVehicule);
assertTrue(Exemptions.evaluer(cheval, defaut, Exemptions.Famille.COMBAT).exempt());
GardeConfig option = new GardeConfig();
option.combatMesureEnVehicule = true;
assertFalse(Exemptions.evaluer(cheval, option, Exemptions.Famille.COMBAT).exempt());
assertTrue(Exemptions.evaluer(siege, option, Exemptions.Famille.COMBAT).raisons().contains("contraption"));
assertTrue(Exemptions.evaluer(cheval, option, Exemptions.Famille.MOUVEMENT).raisons().contains("vehicule"),
"l'option ne touche que le combat");
}
// --- Cache des détections (contraption, courant d'air) ---
@Test
void cacheDeDetectionToutesLesDixTicksPuisGrace() {
Cablage.CacheDetection c = new Cablage.CacheDetection();
AtomicInteger appels = new AtomicInteger();
boolean[] present = {true};
BooleanSupplier detecter = () -> {
appels.incrementAndGet();
return present[0];
};
assertTrue(c.lire(100, detecter, 40));
assertEquals(1, appels.get());
present[0] = false; // la contraption s'éloigne
assertTrue(c.lire(109, detecter, 40), "valeur en cache");
assertEquals(1, appels.get());
assertTrue(c.lire(110, detecter, 40), "redétecté (absent) mais dans la grâce");
assertEquals(2, appels.get());
assertTrue(c.lire(140, detecter, 40));
assertFalse(c.lire(150, detecter, 40), "grâce terminée");
assertTrue(c.lire(5, () -> true, 40), "tick qui recule (redémarrage) : redétecté");
}
@Test
void cacheJamaisVuPasDeGrace() {
Cablage.CacheDetection c = new Cablage.CacheDetection();
assertFalse(c.lire(100, () -> false, 40));
}
}
+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));
}
}
+115 -46
Voir le fichier
@@ -13,8 +13,9 @@ 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.
* Corrigés le 16/10 (branche fix/hitbox-c10-c13-c15) : les anciens tests {@code FAILLE_…} ont été inversés et
* renommés {@code CORRIGE_…}. Chaque faille garde son test « témoin » ; les détections C15 sont des options
* désactivées par défaut, activées ici, avec un témoin honnête qui ne doit rien donner.
* Le contournement n°3 (table SUIVIES pleine) dépend de Minecraft : voir {@code com.gastinelgarde.AutotestSuiviesTest}.
*/
class AutotestContournementsTest {
@@ -78,16 +79,16 @@ class AutotestContournementsTest {
}
@Test
void FAILLE_revue1_pingDeclareAuDessusDe500msExempteTotalementLesCoups() {
void CORRIGE_revue1_pingDeclareAuDessusDe500msNExemptePlusLesCoups() {
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é");
assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs + 1) > 0, "corrigé : à 501 ms, la série est encore vue");
assertTrue(serieHitboxAvecPing(5000) > 0, "corrigé : à 5 s déclarées aussi (fenêtre bornée)");
}
// --- Revue n°2 / C13 : regard et œil du paquet SUIVANT acceptés sans borne --------------------------------------
@Test
void FAILLE_revue2_regardSuivantRameneSurLaCibleEffaceLeCoupHorsBoite() {
void CORRIGE_revue2_regardSuivantRameneSurLaCibleNEffacePlusLeCoupHorsBoite() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double temoin = 0, triche = 0;
for (int k = 0; k < 10; k++) {
@@ -107,11 +108,11 @@ class AutotestContournementsTest {
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)");
assertTrue(triche > 0, "corrigé : un demi-tour du regard au paquet suivant n'est plus accepté");
}
@Test
void FAILLE_revue2_oeilSuivantAvanceDe09BlocEffaceLaPorteeAllongee() {
void CORRIGE_revue2_oeilSuivantAvanceDe09BlocNEffacePlusLaPorteeAllongee() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double temoin = 0, triche = 0;
for (int k = 0; k < 10; k++) {
@@ -131,11 +132,11 @@ class AutotestContournementsTest {
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");
assertTrue(triche > 0, "corrigé : l'œil suivant est borné à un déplacement d'un tick");
}
@Test
void FAILLE_C13_porteeEtHitboxGardentLeMinimumAvecLePaquetSuivant() {
void CORRIGE_C13_porteeEtAngleNeGardentPlusLeMinimumSansBorne() {
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
@@ -151,49 +152,88 @@ class AutotestContournementsTest {
List<Verdict> 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");
assertTrue(points(v, Controle.PORTEE) > 0, "corrigé : s'avancer de 0,8 bloc au paquet suivant n'efface plus la portée");
// Angle killaura : regard à 180° au coup, sur la cible au paquet suivant.
// Angle killaura : regard à 180° au coup, sur la cible au paquet suivant. Un coup isolé n'est pas compté (un
// demi-tour honnête existe : Garde1016Test.angleKillauraRegardEnRetardPasDeFauxPositif) ; une série, si.
// [À VÉRIFIER] Théo : le témoin d'origine portait sur un seul coup.
cfg.mode(Controle.PORTEE, Mode.OFF);
cfg.mode(Controle.HITBOX, Mode.OFF);
moteur = new Moteur(cfg);
double[] oeil = {0, 1.62, -2.5};
List<Verdict> 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");
double serie = 0;
for (int k = 0; k < 10; k++) {
List<Verdict> a = new ArrayList<>(moteur.coupDiffere(joueur, k * 600L, EtatJoueur.normal(), oeil,
new double[] {0, 0, -1}, b, 3.0, 0, false, true));
a.addAll(moteur.regardPorteeHitbox(joueur, k * 600L + 50, oeil, vers(oeil, 0, 1.0, 0)));
if (k == 0) assertEquals(0, points(a, Controle.KILLAURA_ANGLE), 1e-9, "un demi-tour isolé : rien");
serie += points(a, Controle.KILLAURA_ANGLE);
}
assertTrue(serie > 0, "corrigé : rotations silencieuses de 180° répétées vues");
}
/**
* C13, seuils de {@code portee} (3,3 sur cible immobile, 4,3 sur cible qui sprinte) : {@code portee} et
* {@code hitbox} ne sont pas resserrés (ils peuvent être en ENFORCE en production ; tolérance « vitesse × ticks »
* gardée). C'est {@code coups-hors-boite} (mesure sur l'historique de la cible, marge 0,15) qui doit voir ces
* reach en série. Ancien test : {@code FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee},
* qui mesurait {@code portee} seul. [À VÉRIFIER] Théo : accepter que la correction passe par coups-hors-boite.
*/
@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<Verdict> 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");
void CORRIGE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteVusParCoupsHorsBoite() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double immobile = 0, sprint = 0, honnete = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[][] fixes = new double[fenetre + 2][];
for (int i = 0; i < fixes.length; i++) fixes[i] = boite(x);
double[] oeil33 = {x, 1.62, -3.59}; // 3,29 blocs, cible immobile
immobile += points(coupV(k * 600L, oeil33, vers(oeil33, x, 1.0, 0), x, 0, fixes), Controle.COUPS_HORS_BOITE);
}
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");
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil40 = {x, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte
sprint += points(coupV(k * 600L, oeil40, vers(oeil40, x, 1.0, 0), x, V, 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.2}; // 2,9 blocs : honnête
honnete += points(coupV(k * 600L, oeil, vers(oeil, x, 1.0, 0), x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE);
}
assertTrue(immobile > 0, "3,29 blocs sur cible immobile : vu en série");
assertTrue(sprint > 0, "3,99 blocs sur cible qui sprinte : vu en série");
assertEquals(0, honnete, 1e-9, "témoin : 2,9 blocs, rien");
}
private List<Verdict> coupV(long t, double[] oeil, double[] regard, double xCible, double vCible, double[][] vues) {
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, t, EtatJoueur.normal(), oeil, regard,
boite(xCible), 3.0, vCible, true, false, oeil, vues));
vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeil, regard));
return vs;
}
// --- Revue n°4 : la fenêtre d'historique grandit avec le ping déclaré ------------------------------------------
private double serieDerriereLaCible(int ping) {
/** Le joueur a eu {@code pingAvant} pendant une minute, puis déclare {@code ping} pendant le combat. */
private double serieDerriereLaCible(int pingAvant, int ping) {
moteur = new Moteur(cfg);
for (long t = 0; t < 60_000; t += 1000) moteur.pingFenetre(joueur, t, pingAvant);
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg); // ce que Garde.boitesVues calcule depuis latency()
// ce que Garde.boitesVues calcule depuis latency()
int fenetre = PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 60_000, ping), cfg);
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);
// Client « hitbox » : touche loin DERRIÈRE le centre de la cible (là où elle était il y a ~15 ticks).
// 16/10 (correctif) : 4,2 au lieu de 3,6. Avec la marge de 50 ms sur le plancher (30 + 50 ms : 9 ticks
// au lieu de 8), le point à 3,6 tombait au bord de la fenêtre (manque 0,135 < 0,15) ; à 4,2 il reste
// caché par une fenêtre de 16 ticks (450 ms) et vu avec 8 ou 9. [À VÉRIFIER] Théo : témoin modifié.
double[] regard = vers(oeil, x - 4.2, 1.2, 0);
total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE);
}
@@ -201,13 +241,21 @@ class AutotestContournementsTest {
}
@Test
void FAILLE_revue4_pingDeclareA450msElargitLaFenetreEtCacheLaTriche() {
void CORRIGE_revue4_pingGonflePendantLeCombatNElargitPlusLaFenetre() {
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)");
assertTrue(serieDerriereLaCible(450, 450) == 0, "témoin : fenêtre de 16 ticks (450 ms durables), cachée");
assertTrue(serieDerriereLaCible(30, 30) > 0, "témoin : à 30 ms, la série est vue");
moteur = new Moteur(cfg);
for (long t = 0; t < 60_000; t += 1000) moteur.pingFenetre(joueur, t, 30);
assertEquals(9, PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 60_000, 450), cfg),
"corrigé : 30 ms puis 450 annoncés : fenêtre de 9 ticks (plancher 30 + marge 50), pas 16");
assertTrue(serieDerriereLaCible(30, 450) > 0,
"corrigé : 30 ms pendant une minute puis 450 ms annoncés en combat : toujours vu");
// Joueur honnête qui a 450 ms depuis le début : fenêtre complète.
moteur = new Moteur(cfg);
assertEquals(16, PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 0, 450), cfg));
}
// --- C15 : vitesse 0,40 en l'air et Timer 1,09 non vus ---------------------------------------------------------
@@ -230,16 +278,21 @@ class AutotestContournementsTest {
}
@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);
void CORRIGE_C15_bhopA040BlocParTickEstVuAvecLOption() {
// Option désactivée par défaut : comportement inchangé.
assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9, "option coupée : rien (comme avant)");
cfg.vitesseMoyenne = true;
// 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (sprint-saut vanilla : ~0,356 en moyenne, 7,13 m/s).
assertTrue(vitesse(0.40, 0.40, 12, 400) > 0, "corrigé : bhop à 0,40 vu");
assertEquals(0, vitesse(0.356, 0.356, 12, 400), 1e-9, "témoin : sprint-saut vanilla moyen, rien");
}
@Test
void FAILLE_C15_speedAuSolA037BlocParTickNestJamaisVu() {
void CORRIGE_C15_speedAuSolA037BlocParTickEstVuAvecLOption() {
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);
cfg.vitesseMoyenne = true;
assertTrue(vitesse(0.37, 0.37, 1, 400) > 0, "corrigé : 0,37 au sol vu");
assertEquals(0, vitesse(0.28, 0.28, 1, 400), 1e-9, "témoin : sprint vanilla (0,28), rien");
}
private double timer(long intervalleMs, int secondes) {
@@ -252,8 +305,24 @@ class AutotestContournementsTest {
}
@Test
void FAILLE_C15_timerA109NestJamaisVu() {
void CORRIGE_C15_timerA109EstVuAvecLOption() {
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");
assertEquals(0, timer(46, 30), 1e-9, "option coupée : rien (comme avant)");
cfg.timerSoldeMax = 20;
assertTrue(timer(46, 30) > 0, "corrigé : 21,7 paquets/s (timer 1,09) pendant 30 s vu par le solde");
assertEquals(0, timer(50, 60), 1e-9, "témoin : 20 paquets/s, rien");
// Témoin lag : 1 s sans paquet, puis rafale de 20 paquets d'un coup, à répéter.
moteur = new Moteur(cfg);
double lag = 0;
long t = 10_000;
for (int r = 0; r < 20; r++) {
t += 1000;
for (int i = 0; i < 20; i++) lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER);
for (int i = 0; i < 40; i++) {
t += 50;
lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER);
}
}
assertEquals(0, lag, 1e-9, "témoin : rafales de rattrapage après un lag, rien");
}
}
+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);
}
}
+28 -11
Voir le fichier
@@ -15,8 +15,8 @@ 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.
*
* 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.
* ont été inversés et renommés {@code CORRIGE_…}. C10 corrigé le 16/10 (branche fix/hitbox-c10-c13-c15) par une option
* désactivée par défaut ({@code volFenetreGlissante}) : ses tests l'activent et gardent un témoin honnête.
*
* 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
@@ -253,7 +253,8 @@ class AutotestVolIncidentTest {
// --- C10 : sauts en l'air espacés --------------------------------------------------------------------------------
@Test
void FAILLE_C10_unSautEnLAirTousLesDixTicksMonteSansFinSansAucunPoint() {
void CORRIGE_C10_unSautEnLAirTousLesDixTicksEstVuAvecLOption() {
cfg.volFenetreGlissante = true;
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
double total = 0;
double depart = y;
@@ -264,14 +265,32 @@ class AutotestVolIncidentTest {
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
}
}
assertEquals(0, total, 1e-9, "prouvé : aucun point");
// ~0,5 bloc gagné par cycle de 10 ticks : ~15 blocs en 15 s, sans limite.
assertTrue(y - depart > 10, "et le tricheur a gagné " + (y - depart) + " blocs en 15 s");
Mesures.noter(String.format(java.util.Locale.ROOT, "C10 : +%.1f blocs en 300 ticks, 0 point", y - depart));
assertTrue(total > 0, "corrigé : les sauts en l'air répétés sont vus");
Mesures.noter(String.format(java.util.Locale.ROOT, "C10 corrige : %.1f points en 300 ticks", total));
}
@Test
void FAILLE_C10_alternerUnTickAnormalEtUnTickNormalPlaneSansPoint() {
void CORRIGE_C10_temoinSautsHonnetesRepetesAvecLOption() {
cfg.volFenetreGlissante = true;
double total = 0;
for (int cycle = 0; cycle < 30; cycle++) {
total += points(paquet(EtatJoueur.normal(), sol()), Controle.VOL);
double v = 0.42; // saut depuis le sol
double h = 0;
for (int i = 0; i < 40; i++) {
if (h + v <= 0) break; // retour au sol
h += v;
total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL);
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
}
y = Y_SOL;
}
assertEquals(0, total, 1e-9, "témoin : sauts honnêtes répétés, rien");
}
@Test
void CORRIGE_C10_alternerUnTickAnormalEtUnTickNormalEstVuAvecLOption() {
cfg.volFenetreGlissante = true;
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
double total = 0;
double depart = y;
@@ -280,8 +299,6 @@ class AutotestVolIncidentTest {
double dy = i % 2 == 0 ? -0.02 : (-0.02 - VolVertical.GRAVITE) * VolVertical.TRAINEE;
total += points(paquet(EtatJoueur.normal(), air(dy)), Controle.VOL);
}
assertEquals(0, total, 1e-9);
// 200 ticks de chute vanilla depuis l'arrêt : plus de 200 blocs. Ici : ~6 blocs.
assertTrue(depart - y < 15, "descente de " + (depart - y) + " blocs en 10 s (chute lente illimitée)");
assertTrue(total > 0, "corrigé : l'alternance plané / gravité est vue");
}
}
+2 -1
Voir le fichier
@@ -175,7 +175,8 @@ class Garde92Test {
EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().elytres(true).build(),
EtatJoueur.builder().riptide(true).build(),
EtatJoueur.builder().pingMs(cfg.seriePingMaxMs + 1).build(),
// Revue 1 (16/10) : un ping > seriePingMaxMs n'exempte plus (ping falsifiable) ; retiré de la liste,
// voir AutotestContournementsTest.CORRIGE_revue1_… [À VÉRIFIER] Théo.
EtatJoueur.builder().ticksDepuisTeleport(5).build(),
EtatJoueur.builder().ticksDepuisGel(5).build());
for (EtatJoueur etat : etats) {