diff --git a/README.md b/README.md index 72f6968..d259223 100644 --- a/README.md +++ b/README.md @@ -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 ``` diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 5a667ee..03b1ade 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -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 v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etat(p, true), em); + etatMouvement = etat(p, true); + } + if (controler && em != null) { + List 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)); } } diff --git a/src/main/java/com/gastinelgarde/core/Rejeu.java b/src/main/java/com/gastinelgarde/core/Rejeu.java new file mode 100644 index 0000000..4a2745e --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/Rejeu.java @@ -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 infractions, Map vlMax, + List exemples) { } + + private Rejeu() { } + + public static Resume rejouer(Iterable lignes, GardeConfig cfg) { + Moteur moteur = new Moteur(cfg); + Map dernierTick = new HashMap<>(); + Map infractions = new EnumMap<>(Controle.class); + Map vlMax = new EnumMap<>(Controle.class); + List 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 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 [autres traces...]"); + System.exit(2); + } + List 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); + } +} diff --git a/src/main/java/com/gastinelgarde/core/TraceLigne.java b/src/main/java/com/gastinelgarde/core/TraceLigne.java index 6755dd8..601db25 100644 --- a/src/main/java/com/gastinelgarde/core/TraceLigne.java +++ b/src/main/java/com/gastinelgarde/core/TraceLigne.java @@ -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) diff --git a/src/test/java/com/gastinelgarde/core/RejeuTest.java b/src/test/java/com/gastinelgarde/core/RejeuTest.java new file mode 100644 index 0000000..1dcb380 --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/RejeuTest.java @@ -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 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 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 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 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 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 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); + } +}