From fad4da8f7c3a8407d2f629a2936d760053724b71 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Sat, 24 Oct 2026 00:52:23 +0200 Subject: [PATCH] P2.4 : nouveau controle fast-place (OBSERVE par defaut) - core.FastPlace : sur les fastPlaceSerie (40) derniers intervalles entre deux poses (BlockEvent.EntityPlaceEvent, poses du meme tick regroupees), au moins fastPlaceRegularite (90 %) valent exactement le meme nombre de ticks, au plus fastPlaceIntervalleMaxTicks (1 : une pose a chaque tick). - Pas de plafond de poses par seconde : le drag-click humain depasse 20 clics par seconde ; vanilla au clic maintenu pose toutes les 4 ticks (rightClickDelay), jamais a chaque tick avec cette regularite. Une pause de plus d'une seconde remet la serie a zero. - Test de pire cas : poses de Poisson a 20/s pendant 60 s, jamais vues (avec 20 intervalles au lieu de 40, des fausses alertes apparaissaient a 30/s). - En ENFORCE au palier SETBACK la pose est annulee. - Reglages [monde] : fastPlaceSerie, fastPlaceRegularite, fastPlaceIntervalleMaxTicks. - Tests : FastPlaceP2Test (7). Cablage non teste en jeu. Co-Authored-By: Claude Sonnet 5.5 --- src/main/java/com/gastinelgarde/Garde.java | 11 +++ .../java/com/gastinelgarde/GardeEvents.java | 8 ++ .../java/com/gastinelgarde/GardeSpec.java | 12 +++ .../java/com/gastinelgarde/core/Controle.java | 6 +- .../com/gastinelgarde/core/FastPlace.java | 66 +++++++++++++++ .../com/gastinelgarde/core/GardeConfig.java | 6 ++ .../java/com/gastinelgarde/core/Moteur.java | 17 ++++ .../java/com/gastinelgarde/core/Suivi.java | 2 + .../gastinelgarde/core/FastPlaceP2Test.java | 84 +++++++++++++++++++ 9 files changed, 210 insertions(+), 2 deletions(-) create mode 100644 src/main/java/com/gastinelgarde/core/FastPlace.java create mode 100644 src/test/java/com/gastinelgarde/core/FastPlaceP2Test.java diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 73cb8c2..116df62 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -446,6 +446,17 @@ public final class Garde { return Cablage.sanctionDeMouvement(s); } + /** 0.5 (P2.4) : bloc posé par ce joueur. Vrai si la pose doit être annulée (ENFORCE, palier SETBACK ou plus). */ + public static boolean noterPose(ServerPlayer p) { + if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID()) || estExempteManuellement(p.getUUID())) return false; + if (CONFIG.mode(Controle.FAST_PLACE) == Mode.OFF) return false; + int tick = p.server.getTickCount(); + List v = MOTEUR.poseBloc(p.getUUID(), tick * 50L, tick, etat(p, true)); + Sanction s = traiter(p, v); + if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v); + return Cablage.sanctionDeMouvement(s); + } + public static void noterTickServeur(MinecraftServer server, long dureeNs) { double ms = dureeNs / 1_000_000.0; if (ms > 250.0) gelTick = server.getTickCount(); diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index 80cf294..af0a731 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -149,6 +149,14 @@ public final class GardeEvents { if (Garde.noterCasse(p, event.getPos(), event.getState())) event.setCanceled(true); } + /** 0.5 (P2.4) : bloc posé par un joueur (fast-place). En ENFORCE au palier SETBACK, la pose est annulée. */ + @SubscribeEvent(priority = EventPriority.LOWEST) + public static void onPose(net.neoforged.neoforge.event.level.BlockEvent.EntityPlaceEvent event) { + if (event.getLevel().isClientSide()) return; + if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; + if (Garde.noterPose(p)) event.setCanceled(true); + } + /** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */ @SubscribeEvent public static void onRelache(LivingEntityUseItemEvent.Stop event) { diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index 861b1a5..8af86b2 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -32,6 +32,8 @@ public final class GardeSpec { private static final ModConfigSpec.IntValue NO_SLOW_GRACE, NO_SLOW_TICKS; private static final ModConfigSpec.DoubleValue FAST_BREAK_FACTEUR; private static final ModConfigSpec.IntValue FAST_BREAK_TICKS_MIN, FAST_BREAK_SERIE; + private static final ModConfigSpec.IntValue FAST_PLACE_SERIE, FAST_PLACE_INTERVALLE; + private static final ModConfigSpec.DoubleValue FAST_PLACE_REGULARITE; private static final ModConfigSpec.DoubleValue ANGLE_MAX; private static final ModConfigSpec.IntValue CIBLES_MAX; @@ -287,6 +289,13 @@ public final class GardeSpec { .defineInRange("fastBreakTicksMin", 6, 2, 200); FAST_BREAK_SERIE = b.comment("Fast-break : casses suspectes parmi les 10 dernières mesurées (60 s) avant de compter.") .defineInRange("fastBreakSerieMin", 4, 1, 10); + FAST_PLACE_SERIE = b.comment("0.5 (P2.4) fast-place : intervalles entre poses examinés (poses du même tick regroupées).", + "Les clics rapides humains (drag-click) dépassent 20/s mais jamais avec une régularité au tick près.") + .defineInRange("fastPlaceSerie", 40, 5, 64); + FAST_PLACE_REGULARITE = b.comment("Fast-place : part des intervalles qui valent exactement le même nombre de ticks.") + .defineInRange("fastPlaceRegularite", 0.9, 0.5, 1.0); + FAST_PLACE_INTERVALLE = b.comment("Fast-place : cet intervalle commun (ticks) au plus. Vanilla au clic maintenu : 4. 2 = attrape aussi le délai 1.") + .defineInRange("fastPlaceIntervalleMaxTicks", 1, 1, 3); b.pop(); b.comment("0.5 : diagnostics (journal seulement, jamais de sanction).").push("diagnostic"); @@ -464,6 +473,9 @@ public final class GardeSpec { c.fastBreakFacteur = FAST_BREAK_FACTEUR.get(); c.fastBreakTicksMin = FAST_BREAK_TICKS_MIN.get(); c.fastBreakSerieMin = FAST_BREAK_SERIE.get(); + c.fastPlaceSerie = FAST_PLACE_SERIE.get(); + c.fastPlaceRegularite = FAST_PLACE_REGULARITE.get(); + c.fastPlaceIntervalleMaxTicks = FAST_PLACE_INTERVALLE.get(); c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get(); c.setbackSolSiPasDePosition = SETBACK_SOL.get(); c.graceReculTicks = GRACE_RECUL.get(); diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index db79964..f39f210 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -33,7 +33,9 @@ public enum Controle { /** 0.5 (P2.1) : vitesse de marche ou de course gardée pendant un usage d'objet (NoSlow). */ NO_SLOW("no-slow"), /** 0.5 (P2.3) : blocs cassés en série avant la fin de leur temps de casse (FastBreak, la marge vanilla de 30 %). */ - FAST_BREAK("fast-break"); + FAST_BREAK("fast-break"), + /** 0.5 (P2.4) : poses de blocs à chaque tick avec une régularité de machine (FastPlace). */ + FAST_PLACE("fast-place"); private final String id; @@ -62,7 +64,7 @@ public enum Controle { case COUPS_HORS_BOITE, KILLAURA_ANGLE, KILLAURA_CIBLES, CADENCE -> 1; // 0.5 : nouveaux contrôles P1 au plafond « faible » tant qu'ils n'ont pas été validés en jeu. case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS, ANTI_FAIM, - NO_SLOW, FAST_BREAK -> 2; // 0.5 (P2) : idem + NO_SLOW, FAST_BREAK, FAST_PLACE -> 2; // 0.5 (P2) : idem }; } diff --git a/src/main/java/com/gastinelgarde/core/FastPlace.java b/src/main/java/com/gastinelgarde/core/FastPlace.java new file mode 100644 index 0000000..b22a54f --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/FastPlace.java @@ -0,0 +1,66 @@ +package com.gastinelgarde.core; + +/** + * 0.5 (P2.4) : FastPlace. Vanilla 1.21.1 (Minecraft.handleKeybinds, client) : clic droit maintenu = une pose toutes les + * 4 ticks ({@code rightClickDelay}), soit 5 par seconde, parfaitement régulière. Des clics rapides (butterfly, + * drag-click) passent outre ce délai et peuvent dépasser 20 clics par seconde : un simple plafond de poses par seconde + * ferait de fausses alertes. Le module FastPlace (délai 0) pose à chaque tick, avec une régularité qu'aucun clic humain + * n'a : c'est elle qui est mesurée. + * + * Signal : sur les {@link GardeConfig#fastPlaceSerie} derniers intervalles entre deux poses (en ticks serveur, poses du + * même tick regroupées), au moins {@link GardeConfig#fastPlaceRegularite} (90 %) valent exactement le même intervalle + * d, avec {@code d ≤} {@link GardeConfig#fastPlaceIntervalleMaxTicks} (1 par défaut : une pose à chaque tick). Une + * pause de plus d'une seconde remet la série à zéro. Le jitter réseau casse la régularité : il fait manquer un + * tricheur, jamais accuser un joueur honnête. OBSERVE par défaut. + */ +public final class FastPlace { + + public static final int TAILLE_MAX = 64; + /** Pause (ticks) qui termine une série. */ + public static final int PAUSE_TICKS = 20; + + private final int[] intervalles = new int[TAILLE_MAX]; + private int taille; + private int tete; + private long dernierTick = Long.MIN_VALUE; + private int dernierIntervalle; + + /** Une pose de bloc par le joueur au tick serveur donné. @return points d'infraction */ + public double pose(long tick, GardeConfig cfg) { + if (dernierTick != Long.MIN_VALUE && tick == dernierTick) return 0; // même tick : une seule pose comptée + long ecart = dernierTick == Long.MIN_VALUE ? Long.MAX_VALUE : tick - dernierTick; + dernierTick = tick; + if (ecart <= 0 || ecart > PAUSE_TICKS) { + vider(); + dernierTick = tick; + return 0; + } + intervalles[tete] = (int) ecart; + tete = (tete + 1) % TAILLE_MAX; + if (taille < TAILLE_MAX) taille++; + int n = Math.max(2, Math.min(TAILLE_MAX, cfg.fastPlaceSerie)); + if (taille < n) return 0; + // intervalle le plus fréquent parmi les n derniers + int[] compte = new int[PAUSE_TICKS + 1]; + int mode = 0; + for (int k = 0; k < n; k++) { + int v = intervalles[((tete - 1 - k) % TAILLE_MAX + TAILLE_MAX) % TAILLE_MAX]; + if (++compte[v] > compte[mode]) mode = v; + } + dernierIntervalle = mode; + if (mode > cfg.fastPlaceIntervalleMaxTicks || compte[mode] < cfg.fastPlaceRegularite * n) return 0; + vider(); // une infraction par série complète + dernierTick = tick; + return 2.0; + } + + public int dernierIntervalle() { + return dernierIntervalle; + } + + public void vider() { + taille = 0; + tete = 0; + dernierTick = Long.MIN_VALUE; + } +} diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index 165c466..fb5a949 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -194,6 +194,12 @@ public final class GardeConfig { public int fastBreakTicksMin = 6; /** FastBreak : casses suspectes parmi les 10 dernières mesurées (60 s) avant de compter. */ public int fastBreakSerieMin = 4; + /** FastPlace : intervalles entre poses examinés (poses du même tick regroupées). */ + public int fastPlaceSerie = 40; + /** FastPlace : part de ces intervalles qui doivent valoir exactement le même nombre de ticks. */ + public double fastPlaceRegularite = 0.9; + /** FastPlace : cet intervalle commun (ticks) au plus ; vanilla au clic maintenu : 4. */ + public int fastPlaceIntervalleMaxTicks = 1; // --- 0.5 (P1.13, section [diagnostic]) : journal seulement, jamais de sanction --- /** Journaliser les ABORT de casse de bloc sans START correspondant (« Mismatch in destroy block pos »). */ diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index b7d73da..c9169cf 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -504,6 +504,23 @@ public final class Moteur { return v; } + /** Un bloc vient d'être posé par le joueur (BlockEvent.EntityPlaceEvent) : fast-place. */ + public List poseBloc(UUID joueur, long nowMs, long tick, EtatJoueur etat) { + if (expulses.contains(joueur) || cfg.mode(Controle.FAST_PLACE) == Mode.OFF) return List.of(); + Suivi s = suivi(joueur); + Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE); + if (ex.exempt()) { + s.fastPlace.vider(); + return List.of(); + } + double pts = s.fastPlace.pose(tick, cfg); + List v = new ArrayList<>(1); + ajouter(v, s, Controle.FAST_PLACE, pts, nowMs, ex, String.format(Locale.ROOT, + "%d poses a intervalle regulier de %d tick(s) (vanilla au clic maintenu : 4)", cfg.fastPlaceSerie, + s.fastPlace.dernierIntervalle())); + return v; + } + /** * L'exemption tient-elle à un état dont la fin arrive en retard côté serveur (élytres, riptide, véhicule, vol, * contraption, lévitation, chute lente, mode de jeu) ? Une grâce seule (téléportation, recul) : non. diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index 918d9d8..9759486 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -69,6 +69,8 @@ public final class Suivi { public final NoSlow noSlow = new NoSlow(); /** 0.5 (P2.3) : fast-break. */ public final FastBreak fastBreak = new FastBreak(); + /** 0.5 (P2.4) : fast-place. */ + public final FastPlace fastPlace = new FastPlace(); /** 0.5 (P1.6) : déploiements d'élytres répétés. */ public final DeploiementsElytres deploiements = new DeploiementsElytres(); /** 0.5 (P1.13) : diagnostic des actions de casse de bloc. */ diff --git a/src/test/java/com/gastinelgarde/core/FastPlaceP2Test.java b/src/test/java/com/gastinelgarde/core/FastPlaceP2Test.java new file mode 100644 index 0000000..95a0899 --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/FastPlaceP2Test.java @@ -0,0 +1,84 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Random; +import java.util.UUID; +import org.junit.jupiter.api.Test; + +/** 0.5, P2.4 : fast-place (régularité des poses au tick près). */ +class FastPlaceP2Test { + + private final GardeConfig cfg = new GardeConfig(); + private final UUID joueur = UUID.randomUUID(); + + private double poser(Moteur m, EtatJoueur etat, long[] ticks) { + double pts = 0; + for (long t : ticks) { + for (Verdict v : m.poseBloc(joueur, t * 50L, t, etat)) { + if (v.controle() == Controle.FAST_PLACE) pts += v.points(); + } + } + return pts; + } + + private static long[] reguliers(int n, int intervalle) { + long[] t = new long[n]; + for (int i = 0; i < n; i++) t[i] = 100 + (long) i * intervalle; + return t; + } + + @Test + void observeParDefaut() { + assertEquals(Mode.OBSERVE, cfg.mode(Controle.FAST_PLACE)); + assertEquals(Controle.FAST_PLACE, Controle.parse("fast-place")); + } + + @Test + void poseAChaqueTickVue() { + assertTrue(poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(45, 1)) > 0); + } + + @Test + void clicMaintenuVanillaJamaisVu() { + // 4 ticks entre deux poses, parfaitement régulier : vanilla. + assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(200, 4)), 1e-9); + } + + @Test + void delaiUnSeulementSiConfigure() { + assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(50, 2)), 1e-9); + cfg.fastPlaceIntervalleMaxTicks = 2; + assertTrue(poser(new Moteur(cfg), EtatJoueur.normal(), reguliers(50, 2)) > 0); + } + + @Test + void dragClickIrregulierJamaisVu() { + // Poses de Poisson à 20/s (1 par tick) pendant 60 s, irréaliste (il faudrait 20 cibles par seconde) mais + // pire cas : intervalles 0 (même tick), 1, 2, 3… + Random r = new Random(42); + long[] t = new long[1200]; + double temps = 100; + for (int i = 0; i < t.length; i++) { + temps += -Math.log(1 - r.nextDouble()) / 1.0; + t[i] = (long) temps; + } + assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), t), 1e-9); + } + + @Test + void pauseRemetAZero() { + long[] t = new long[60]; + for (int i = 0; i < 60; i++) t[i] = 100 + i + (i >= 30 ? 100 : 0); // 30 + 30 poses séparées de 5 s + assertEquals(0, poser(new Moteur(cfg), EtatJoueur.normal(), t), 1e-9); + } + + @Test + void exemptions() { + for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(), + EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().ticksDepuisGel(3).build()}) { + assertEquals(0, poser(new Moteur(cfg), e, reguliers(60, 1)), 1e-9, e.toString()); + } + } +}