GastinelGarde : rejeu des traces (Rejeu), masque de mouvement enrichi, 98 tests

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Sonnet 5.5 a révisé 2026-10-14 00:16:16 +02:00
1 Parent a70809df6c
révision 5631ebf506
5 fichiers modifiés
+334 -5

Aucun fichier ne correspond à votre recherche

+16 -1
Voir le fichier
@@ -3,7 +3,7 @@
Anti-triche maison pour le serveur NeoForge 1.21.1 de Théo (mod côté serveur uniquement). Plan et décisions :
`../PLAN-GASTINELGARDE.md`. Version **0.2.0** : phases 0, 1 et 2 du plan.
**État** : compilé, 90 tests JUnit verts (cœur pur, commandes, configuration, application réelle des mixins).
**État** : compilé, 98 tests JUnit verts (cœur pur, commandes, configuration, application réelle des mixins).
**Jamais testé en jeu.** Tous les contrôles démarrent en `OBSERVE` (journal et message aux ops, aucune sanction).
Il n'y a jamais de bannissement automatique.
@@ -85,6 +85,21 @@ Plafond configurable (`sanctionMax`). Les points décroissent de 0,5 par seconde
maximum par défaut (`[traces]` dans la configuration). Ordre de grandeur : 20 lignes par seconde et par
joueur, environ 150 octets par ligne, donc environ 10 Mo par heure et par joueur connecté.
## Régler les seuils avec les traces (rejeu)
Les traces JSONL se rejouent dans le moteur, sans serveur :
```
java -cp build/libs/gastinelgarde-neoforge-1.21.1-0.2.0.jar com.gastinelgarde.core.Rejeu trace-2026-10-14.jsonl
```
Sortie : nombre de mouvements et d'attaques, infractions et points maximaux par contrôle, vingt exemples. Méthode :
enregistrer une session honnête (marche, course, sauts, chute, glace, échelle, eau, riptide, élytres, bateau
volant Create, combat) et une session avec le client de triche, rejouer les deux, puis ajuster les seuils
(`excesVitesseBlocs`, `angleMaxDegres`, …) jusqu'à zéro infraction sur la première et des infractions franches sur
la seconde. Le timer n'est pas rejouable (la trace n'a pas le temps réel des paquets). Un test JUnit
(`RejeuTest`) couvre le principe.
## Construire et déployer
```
+12 -4
Voir le fichier
@@ -327,14 +327,20 @@ public final class Garde {
boolean solServeur = auSolServeur(p);
// Phase 2 : no-fall (divergence), vitesse horizontale, vol.
if (mouvementControlesActifs() && !estExempteManuellement(p.getUUID()) && m.mouvementTick != Integer.MIN_VALUE) {
boolean controler = mouvementControlesActifs() && !estExempteManuellement(p.getUUID());
EtatMouvement em = null;
EtatJoueur etatMouvement = null;
if ((controler || tracesEnCours()) && m.mouvementTick != Integer.MIN_VALUE) {
double dx = p.getX() - m.mouvementX;
double dz = p.getZ() - m.mouvementZ;
EtatMouvement em = new EtatMouvement(Math.sqrt(dx * dx + dz * dz), p.getY() - m.mouvementY,
em = new EtatMouvement(Math.sqrt(dx * dx + dz * dz), p.getY() - m.mouvementY,
tick - m.mouvementTick, p.onGround(), solServeur, p.isSprinting(), p.isShiftKeyDown(),
p.isUsingItem(), niveau(p, MobEffects.MOVEMENT_SPEED), niveau(p, MobEffects.MOVEMENT_SLOWDOWN),
milieuSpecial(p), frictionAnormale(p));
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etat(p, true), em);
etatMouvement = etat(p, true);
}
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);
}
@@ -356,8 +362,10 @@ public final class Garde {
m.dernierY = p.getY();
m.dernierZ = p.getZ();
m.aDernierePosition = true;
EtatJoueur etatTrace = etatMouvement != null ? etatMouvement : etat(p, true);
tracer(new TraceLigne(tick, p.getGameProfile().getName(), "move", p.getX(), p.getY(), p.getZ(),
vx, vy, vz, p.onGround(), solServeur, TraceLigne.masque(etat(p, false)), -1, Double.NaN, null));
vx, vy, vz, p.onGround(), solServeur, TraceLigne.masqueMouvement(etatTrace, em, CONFIG),
-1, Double.NaN, null));
}
}
+175
Voir le fichier
@@ -0,0 +1,175 @@
package com.gastinelgarde.core;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.EnumMap;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;
/**
* Rejeu des traces JSONL dans le moteur (décision D11 : des seuils mesurés, pas devinés). On enregistre une
* session honnête et une session de triche, on les rejoue avec des seuils différents et on regarde ce qui
* lève des infractions.
*
* Usage : {@code java -cp gastinelgarde.jar com.gastinelgarde.core.Rejeu trace-2026-10-14.jsonl [autres...]}
*
* Limites : le timer (débit réel des paquets) n'est pas rejouable, la trace n'ayant pas le temps réel des
* paquets. Le rejeu des mouvements suppose une trace par tick ; l'écart entre deux traces d'un même joueur
* donne le nombre de ticks.
*/
public final class Rejeu {
public record Resume(int lignes, int mouvements, int attaques, int ignorees,
Map<Controle, Integer> infractions, Map<Controle, Double> vlMax,
List<String> exemples) { }
private Rejeu() { }
public static Resume rejouer(Iterable<String> lignes, GardeConfig cfg) {
Moteur moteur = new Moteur(cfg);
Map<String, Long> dernierTick = new HashMap<>();
Map<Controle, Integer> infractions = new EnumMap<>(Controle.class);
Map<Controle, Double> vlMax = new EnumMap<>(Controle.class);
List<String> exemples = new ArrayList<>();
int n = 0, moves = 0, atks = 0, ignorees = 0;
for (String ligne : lignes) {
if (ligne == null || ligne.isBlank()) continue;
n++;
String ev = texte(ligne, "ev");
String nom = texte(ligne, "j");
if (ev == null || nom == null || Double.isNaN(nombre(ligne, "t"))) {
ignorees++;
continue;
}
long tick = (long) nombre(ligne, "t");
int f = (int) nombre(ligne, "f", 0);
UUID id = UUID.nameUUIDFromBytes(nom.getBytes(StandardCharsets.UTF_8));
EtatJoueur etat = etatDepuisMasque(f);
List<Verdict> verdicts = List.of();
if (ev.equals("move")) {
moves++;
Long precedent = dernierTick.put(nom, tick);
int ticks = precedent == null ? 1 : (int) Math.max(1, tick - precedent);
double vx = nombre(ligne, "vx", 0), vy = nombre(ligne, "vy", 0), vz = nombre(ligne, "vz", 0);
EtatMouvement em = new EtatMouvement(Math.sqrt(vx * vx + vz * vz), vy, ticks,
nombre(ligne, "sc", 0) != 0, nombre(ligne, "ss", 0) != 0,
(f & TraceLigne.F_SPRINT) != 0, (f & TraceLigne.F_FURTIF) != 0,
(f & TraceLigne.F_UTILISE_OBJET) != 0,
(f >> TraceLigne.DECALAGE_VITESSE) & 15, (f >> TraceLigne.DECALAGE_LENTEUR) & 15,
(f & TraceLigne.F_MILIEU) != 0, (f & TraceLigne.F_FRICTION) != 0);
verdicts = precedent == null ? List.of() : moteur.mouvement(id, tick * 50L, etat, em);
} else if (ev.equals("atk")) {
atks++;
String msg = texte(ligne, "m");
verdicts = moteur.attaque(id, tick * 50L, etat, nombre(ligne, "a", -1),
(int) nombre(ligne, "c", 0), !"non-visible".equals(msg));
} else {
ignorees++;
}
for (Verdict v : verdicts) {
infractions.merge(v.controle(), 1, Integer::sum);
vlMax.merge(v.controle(), v.vl(), Math::max);
if (exemples.size() < 20) {
exemples.add(String.format(Locale.ROOT, "t=%d %s %s vl=%.1f %s", tick, nom, v.controle().id(),
v.vl(), v.details()));
}
}
}
return new Resume(n, moves, atks, ignorees, infractions, vlMax, exemples);
}
/** État du joueur déduit du masque enregistré (les durées de grâce valent 0 si la marque est présente). */
static EtatJoueur etatDepuisMasque(int f) {
return EtatJoueur.builder()
.creatif((f & TraceLigne.F_CREATIF) != 0)
.spectateur((f & TraceLigne.F_SPECTATEUR) != 0)
.peutVoler((f & TraceLigne.F_PEUT_VOLER) != 0)
.riptide((f & TraceLigne.F_RIPTIDE) != 0)
.elytres((f & TraceLigne.F_ELYTRES) != 0)
.levitation((f & TraceLigne.F_LEVITATION) != 0)
.chuteLente((f & TraceLigne.F_CHUTE_LENTE) != 0)
.enVehicule((f & TraceLigne.F_VEHICULE) != 0)
.pocheContraption((f & TraceLigne.F_CONTRAPTION) != 0)
.utiliseObjet((f & TraceLigne.F_UTILISE_OBJET) != 0)
.ticksDepuisTeleport((f & TraceLigne.F_TELEPORT) != 0 ? 0 : EtatJoueur.JAMAIS)
.ticksDepuisRecul((f & TraceLigne.F_RECUL) != 0 ? 0 : EtatJoueur.JAMAIS)
.ticksDepuisGel((f & TraceLigne.F_GEL) != 0 ? 0 : EtatJoueur.JAMAIS)
.build();
}
// --- Lecture minimale du JSON produit par TraceLigne (clés connues, pas de bibliothèque) ---
static double nombre(String ligne, String cle) {
return nombre(ligne, cle, Double.NaN);
}
static double nombre(String ligne, String cle, double defaut) {
int i = ligne.indexOf("\"" + cle + "\":");
if (i < 0) return defaut;
int debut = i + cle.length() + 3;
int fin = debut;
while (fin < ligne.length() && "-+.0123456789eE".indexOf(ligne.charAt(fin)) >= 0) fin++;
if (fin == debut) return defaut;
try {
return Double.parseDouble(ligne.substring(debut, fin));
} catch (NumberFormatException e) {
return defaut;
}
}
static String texte(String ligne, String cle) {
int i = ligne.indexOf("\"" + cle + "\":\"");
if (i < 0) return null;
StringBuilder sb = new StringBuilder();
for (int p = i + cle.length() + 4; p < ligne.length(); p++) {
char c = ligne.charAt(p);
if (c == '"') return sb.toString();
if (c == '\\' && p + 1 < ligne.length()) {
char s = ligne.charAt(++p);
switch (s) {
case 'n' -> sb.append('\n');
case 'r' -> sb.append('\r');
case 't' -> sb.append('\t');
case 'u' -> {
if (p + 4 < ligne.length()) {
sb.append((char) Integer.parseInt(ligne.substring(p + 1, p + 5), 16));
p += 4;
}
}
default -> sb.append(s);
}
} else {
sb.append(c);
}
}
return null;
}
public static void main(String[] args) throws IOException {
if (args.length == 0) {
System.err.println("Usage : Rejeu <trace.jsonl> [autres traces...]");
System.exit(2);
}
List<String> toutes = new ArrayList<>();
for (String a : args) toutes.addAll(Files.readAllLines(Path.of(a), StandardCharsets.UTF_8));
Resume r = rejouer(toutes, new GardeConfig());
System.out.printf(Locale.ROOT, "%d lignes, %d mouvements, %d attaques, %d ignorées%n",
r.lignes(), r.mouvements(), r.attaques(), r.ignorees());
for (Controle c : Controle.values()) {
Integer n = r.infractions().get(c);
if (n == null) continue;
System.out.printf(Locale.ROOT, " %-20s %6d infractions, VL max %.1f%n", c.id(), n, r.vlMax().get(c));
}
if (r.infractions().isEmpty()) System.out.println(" aucune infraction");
for (String e : r.exemples()) System.out.println(" " + e);
}
}
+27
Voir le fichier
@@ -18,6 +18,12 @@ public record TraceLigne(long tick, String joueur, String evenement,
public static final int F_CREATIF = 1, F_SPECTATEUR = 2, F_PEUT_VOLER = 4, F_RIPTIDE = 8, F_ELYTRES = 16,
F_LEVITATION = 32, F_CHUTE_LENTE = 64, F_VEHICULE = 128, F_CONTRAPTION = 256, F_UTILISE_OBJET = 512;
// Bits propres aux traces de mouvement (rejeu, voir Rejeu) : état déduit au moment de l'enregistrement.
public static final int F_SPRINT = 1 << 10, F_FURTIF = 1 << 11, F_MILIEU = 1 << 12, F_FRICTION = 1 << 13,
F_TELEPORT = 1 << 14, F_RECUL = 1 << 15, F_GEL = 1 << 16;
/** Bits 17 à 20 : niveau de Vitesse (0 à 15). Bits 21 à 24 : niveau de Lenteur (0 à 15). */
public static final int DECALAGE_VITESSE = 17, DECALAGE_LENTEUR = 21;
public static int masque(EtatJoueur e) {
int m = 0;
if (e.creatif()) m |= F_CREATIF;
@@ -33,6 +39,27 @@ public record TraceLigne(long tick, String joueur, String evenement,
return m;
}
/**
* Masque complet d'un tick de mouvement : exemptions, état de déplacement et marques de grâce (téléportation,
* recul, gel, selon les durées de la configuration).
*/
public static int masqueMouvement(EtatJoueur e, EtatMouvement m, GardeConfig cfg) {
int f = masque(e);
if (m != null) {
if (m.sprint()) f |= F_SPRINT;
if (m.furtif()) f |= F_FURTIF;
if (m.ralentiParObjet()) f |= F_UTILISE_OBJET;
if (m.milieuSpecial()) f |= F_MILIEU;
if (m.frictionAnormale()) f |= F_FRICTION;
f |= (Math.min(15, Math.max(0, m.amplificateurVitesse())) << DECALAGE_VITESSE);
f |= (Math.min(15, Math.max(0, m.amplificateurLenteur())) << DECALAGE_LENTEUR);
}
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) f |= F_TELEPORT;
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) f |= F_RECUL;
if (e.ticksDepuisGel() <= cfg.graceGelTicks) f |= F_GEL;
return f;
}
public String json() {
StringBuilder sb = new StringBuilder(160);
sb.append("{\"t\":").append(tick)
+104
Voir le fichier
@@ -0,0 +1,104 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.List;
import org.junit.jupiter.api.Test;
class RejeuTest {
private static String move(long tick, String joueur, double vx, double vy, double vz, boolean sol, int masque) {
return new TraceLigne(tick, joueur, "move", 0, 64, 0, vx, vy, vz, sol, sol, masque, -1, Double.NaN, null).json();
}
private static String attaque(long tick, String joueur, double angle, int cible) {
return new TraceLigne(tick, joueur, "atk", 0, 64, 0, 0, 0, 0, true, true, 0, cible, angle, null).json();
}
private static int masque(boolean sprint) {
return sprint ? TraceLigne.F_SPRINT : 0;
}
@Test
void lectureDesChampsEtEchappement() {
String l = new TraceLigne(7, "ga\"by", "move", 1.5, 2, 3, 0.25, -0.5, 0, true, false, 42, 9, 12.5, "a\nb").json();
assertEquals(7, Rejeu.nombre(l, "t"), 0);
assertEquals("ga\"by", Rejeu.texte(l, "j"));
assertEquals("a\nb", Rejeu.texte(l, "m"));
assertEquals(-0.5, Rejeu.nombre(l, "vy"), 1e-9);
assertEquals(42, (int) Rejeu.nombre(l, "f"));
assertEquals(12.5, Rejeu.nombre(l, "a"), 1e-9);
assertTrue(Double.isNaN(Rejeu.nombre(l, "absent")));
assertNull(Rejeu.texte(l, "absent"));
}
@Test
void sessionHonneteSansInfraction() {
List<String> trace = new ArrayList<>();
for (int t = 0; t < 200; t++) trace.add(move(t, "Theo", 0.0, 0.0, 0.27, true, masque(true)));
Rejeu.Resume r = Rejeu.rejouer(trace, new GardeConfig());
assertEquals(200, r.mouvements());
assertTrue(r.infractions().isEmpty());
}
@Test
void speedHackDetecte() {
List<String> trace = new ArrayList<>();
for (int t = 0; t < 200; t++) trace.add(move(t, "Triche", 0.0, 0.0, 0.8, true, masque(true)));
Rejeu.Resume r = Rejeu.rejouer(trace, new GardeConfig());
assertTrue(r.infractions().getOrDefault(Controle.VITESSE, 0) > 0);
assertTrue(r.vlMax().get(Controle.VITESSE) > 0);
}
@Test
void leReglageDesSeuilsChangeLeResultat() {
List<String> trace = new ArrayList<>();
for (int t = 0; t < 100; t++) trace.add(move(t, "Theo", 0.0, 0.0, 0.40, true, masque(true))); // 0,10 d'excès par tick
GardeConfig strict = new GardeConfig();
GardeConfig large = new GardeConfig();
large.excesVitesseBlocs = 50;
assertTrue(Rejeu.rejouer(trace, strict).infractions().getOrDefault(Controle.VITESSE, 0) > 0);
assertEquals(0, Rejeu.rejouer(trace, large).infractions().getOrDefault(Controle.VITESSE, 0));
}
@Test
void killauraDetectee() {
List<String> trace = new ArrayList<>();
for (int t = 0; t < 10; t++) trace.add(attaque(t * 12L, "Triche", 150, 5));
Rejeu.Resume r = Rejeu.rejouer(trace, new GardeConfig());
assertEquals(10, r.attaques());
assertTrue(r.infractions().getOrDefault(Controle.KILLAURA_ANGLE, 0) > 0);
}
@Test
void exemptionsDuMasqueRespectees() {
List<String> trace = new ArrayList<>();
int riptide = TraceLigne.F_RIPTIDE | TraceLigne.F_SPRINT;
for (int t = 0; t < 100; t++) trace.add(move(t, "Theo", 0.0, 0.0, 3.0, false, riptide));
assertTrue(Rejeu.rejouer(trace, new GardeConfig()).infractions().isEmpty());
}
@Test
void niveauxDEffetsEtMarquesDeGrace() {
GardeConfig cfg = new GardeConfig();
EtatJoueur e = EtatJoueur.builder().ticksDepuisTeleport(3).ticksDepuisRecul(100).build();
EtatMouvement m = new EtatMouvement(0.3, 0, 1, true, true, true, false, false, 2, 1, false, false);
int f = TraceLigne.masqueMouvement(e, m, cfg);
assertTrue((f & TraceLigne.F_TELEPORT) != 0);
assertEquals(0, f & TraceLigne.F_RECUL);
assertTrue((f & TraceLigne.F_SPRINT) != 0);
assertEquals(2, (f >> TraceLigne.DECALAGE_VITESSE) & 15);
assertEquals(1, (f >> TraceLigne.DECALAGE_LENTEUR) & 15);
}
@Test
void lignesIllisiblesIgnorees() {
List<String> trace = List.of("pas du json", "{\"t\":1}", "", "{\"t\":2,\"j\":\"X\",\"ev\":\"tp\"}");
Rejeu.Resume r = Rejeu.rejouer(trace, new GardeConfig());
assertEquals(0, r.mouvements());
assertTrue(r.ignorees() >= 2);
}
}