diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 9e475ee..73cb8c2 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -424,6 +424,28 @@ public final class Garde { if (ligne != null) ecrireJournal("DIAGNOSTIC " + p.getGameProfile().getName() + " casse de bloc : " + ligne); } } + /** 0.5 (P2.3) : START de casse accepté : début de la mesure fast-break. */ + public static void noterDebutCasse(ServerPlayer p, BlockPos pos) { + if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return; + MOTEUR.debutCasse(p.getUUID(), p.server.getTickCount(), pos.getX(), pos.getY(), pos.getZ()); + } + + /** + * 0.5 (P2.3) : bloc cassé par ce joueur. Renvoie vrai si la casse doit être annulée (fast-break en ENFORCE, palier + * SETBACK ou plus) ; une EXPULSION est appliquée ici. + */ + public static boolean noterCasse(ServerPlayer p, BlockPos pos, BlockState state) { + if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID()) || estExempteManuellement(p.getUUID())) return false; + if (CONFIG.mode(Controle.FAST_BREAK) == Mode.OFF) return false; + int tick = p.server.getTickCount(); + double progression = state.getDestroyProgress(p, p.level(), pos); + List v = MOTEUR.casseBloc(p.getUUID(), tick * 50L, tick, etat(p, true), pos.getX(), pos.getY(), + pos.getZ(), progression); + 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 2855179..80cf294 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -130,10 +130,25 @@ public final class GardeEvents { if (event.getLevel().isClientSide()) return; if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; var a = event.getAction(); + // 0.5 (P2.3) : début de la mesure fast-break (START accepté par les autres mods). + if (a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START && !event.isCanceled()) { + Garde.noterDebutCasse(p, event.getPos()); + } Garde.noterActionBloc(p, a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START, a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.ABORT, event.getPos(), event.isCanceled()); } + /** + * 0.5 (P2.3) : bloc cassé par un joueur (fast-break). En ENFORCE au palier SETBACK, la casse est annulée (le bloc + * reste) ; l'expulsion s'applique comme ailleurs. Câblage non testé en jeu. + */ + @SubscribeEvent(priority = EventPriority.LOWEST) + public static void onCasse(net.neoforged.neoforge.event.level.BlockEvent.BreakEvent event) { + if (event.getLevel().isClientSide()) return; + if (!(event.getPlayer() instanceof ServerPlayer p) || p instanceof FakePlayer) return; + if (Garde.noterCasse(p, event.getPos(), event.getState())) 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 0057c1a..861b1a5 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -30,6 +30,8 @@ public final class GardeSpec { // 0.5 (P2) private static final ModConfigSpec.DoubleValue NO_SLOW_FACTEUR; 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.DoubleValue ANGLE_MAX; private static final ModConfigSpec.IntValue CIBLES_MAX; @@ -277,6 +279,16 @@ public final class GardeSpec { .defineInRange("noSlowTicks", 10, 2, 200); b.pop(); + b.comment("0.5 (P2) : casse et pose de blocs. Nouveaux contrôles en OBSERVE par défaut.").push("monde"); + FAST_BREAK_FACTEUR = b.comment("0.5 (P2.3) fast-break : rapport (progression par tick × ticks depuis le START) sous lequel une casse est suspecte.", + "Vanilla accepte la casse dès 0,7 ; un client honnête casse vers 1,0.") + .defineInRange("fastBreakFacteur", 0.8, 0.7, 1.0); + FAST_BREAK_TICKS_MIN = b.comment("Fast-break : blocs plus rapides que ce nombre de ticks non mesurés.") + .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); + b.pop(); + b.comment("0.5 : diagnostics (journal seulement, jamais de sanction).").push("diagnostic"); DIAG_ACTIONS = b.comment("Journaliser les ABORT de casse de bloc sans START correspondant (message vanilla « Mismatch in destroy block pos »),", "au plus une ligne toutes les 10 s par joueur.") @@ -449,6 +461,9 @@ public final class GardeSpec { c.noSlowFacteur = NO_SLOW_FACTEUR.get(); c.noSlowGraceTicks = NO_SLOW_GRACE.get(); c.noSlowTicks = NO_SLOW_TICKS.get(); + c.fastBreakFacteur = FAST_BREAK_FACTEUR.get(); + c.fastBreakTicksMin = FAST_BREAK_TICKS_MIN.get(); + c.fastBreakSerieMin = FAST_BREAK_SERIE.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 e3a5228..db79964 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -31,7 +31,9 @@ public enum Controle { /** 0.5 (P1.8) : course au sol déclarée « en l'air » par le client pour ne pas perdre de faim (AntiHunger). */ ANTI_FAIM("anti-faim"), /** 0.5 (P2.1) : vitesse de marche ou de course gardée pendant un usage d'objet (NoSlow). */ - NO_SLOW("no-slow"); + 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"); private final String id; @@ -60,7 +62,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 -> 2; // 0.5 (P2) : idem + NO_SLOW, FAST_BREAK -> 2; // 0.5 (P2) : idem }; } diff --git a/src/main/java/com/gastinelgarde/core/Exemptions.java b/src/main/java/com/gastinelgarde/core/Exemptions.java index d2ffea6..7a799f1 100644 --- a/src/main/java/com/gastinelgarde/core/Exemptions.java +++ b/src/main/java/com/gastinelgarde/core/Exemptions.java @@ -9,7 +9,7 @@ import java.util.List; */ public final class Exemptions { - public enum Famille { COMBAT, MOUVEMENT, TIMER, VEHICULE } + public enum Famille { COMBAT, MOUVEMENT, TIMER, VEHICULE, MONDE } /** * @param exempt le contrôle ne doit pas s'appliquer @@ -55,6 +55,13 @@ public final class Exemptions { if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul"); if (e.connexionRecente()) raisons.add("connexion"); } + case MONDE -> { + // 0.5 (P2) : casse et pose de blocs. Vaisseau Sable / contraption : coordonnées de sous-niveau, et + // gel du serveur : les paquets arrivent groupés, les temps mesurés ne veulent rien dire. + if (e.pocheContraption()) raisons.add("contraption"); + if (e.ticksDepuisGel() <= cfg.graceGelTicks) raisons.add("gel-serveur"); + if (e.connexionRecente()) raisons.add("connexion"); + } case TIMER -> { if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation"); if (e.connexionRecente()) raisons.add("connexion"); // rafale de paquets du chargement diff --git a/src/main/java/com/gastinelgarde/core/FastBreak.java b/src/main/java/com/gastinelgarde/core/FastBreak.java new file mode 100644 index 0000000..d68d8cc --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/FastBreak.java @@ -0,0 +1,71 @@ +package com.gastinelgarde.core; + +/** + * 0.5 (P2.3) : FastBreak. Vanilla 1.21.1 (ServerPlayerGameMode.handleBlockBreakAction, vérifié dans les sources + * NeoForge 21.1.234) accepte un STOP_DESTROY_BLOCK dès que {@code getDestroyProgress × (ticks depuis START + 1) ≥ 0,7} : + * le serveur laisse 30 % d'avance au client. Les modules FastBreak s'arrêtent juste au-dessus de 0,7 ; un client + * honnête envoie STOP quand sa propre progression atteint 1, donc un rapport proche de 1 (au jitter réseau près). + * + * Mesure, à la casse effective (BlockEvent.BreakEvent) d'un bloc dont le START a été vu au même endroit : + * {@code rapport = progression par tick (serveur, outil et effets du moment) × (ticks écoulés + 1)}. Un rapport sous + * {@link GardeConfig#fastBreakFacteur} (0,8) est suspect. Les blocs qui demandent moins de + * {@link GardeConfig#fastBreakTicksMin} ticks ne sont pas mesurés (un tick de jitter y pèse trop) ; les blocs cassés + * d'un coup (progression ≥ 1) non plus. Un START retardé par le réseau raccourcit la mesure (faux positif possible) : + * points seulement en série ({@link GardeConfig#fastBreakSerieMin} casses suspectes sur les {@link #SERIE} dernières + * mesurées, en {@link #FENETRE_MS} ms). OBSERVE par défaut. + */ +public final class FastBreak { + + public static final int SERIE = 10; + public static final long FENETRE_MS = 60_000; + + private boolean debut; + private int x, y, z; + private long debutTick; + private double dernierRapport = Double.NaN; + private int dernierCompte; + private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS); + + /** START_DESTROY_BLOCK accepté (non annulé) sur ce bloc, au tick serveur donné. */ + public void debut(long tick, int x, int y, int z) { + debut = true; + this.x = x; + this.y = y; + this.z = z; + debutTick = tick; + } + + /** + * Le bloc vient d'être cassé par le joueur. + * + * @param progression progression de casse par tick vue par le serveur ({@code getDestroyProgress}) ; NaN = inconnue + * @return points d'infraction (0 si rien) + */ + public double casse(long nowMs, long tick, int x, int y, int z, double progression, GardeConfig cfg) { + boolean memeBloc = debut && this.x == x && this.y == y && this.z == z; + debut = false; + dernierRapport = Double.NaN; + if (!memeBloc || Double.isNaN(progression) || progression <= 0 || progression >= 1.0) return 0; + long ticks = tick - debutTick; + if (ticks < 0) return 0; + double attendus = Math.ceil(1.0 / progression); + if (attendus < cfg.fastBreakTicksMin) return 0; + dernierRapport = progression * (ticks + 1); + boolean suspect = dernierRapport < cfg.fastBreakFacteur; + dernierCompte = serie.ajouter(nowMs, suspect); + if (!suspect || dernierCompte < Math.max(1, cfg.fastBreakSerieMin)) return 0; + return 2.0; + } + + public double dernierRapport() { + return dernierRapport; + } + + public int dernierCompte() { + return dernierCompte; + } + + public void vider() { + debut = false; + } +} diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index 875dd4c..165c466 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -188,6 +188,12 @@ public final class GardeConfig { public int noSlowGraceTicks = 3; /** NoSlow : paquets suspects consécutifs avant infraction. */ public int noSlowTicks = 10; + /** FastBreak : rapport progression × ticks sous lequel une casse est suspecte (vanilla accepte dès 0,7). */ + public double fastBreakFacteur = 0.8; + /** FastBreak : blocs plus rapides que ce nombre de ticks non mesurés (un tick de jitter y pèse trop). */ + public int fastBreakTicksMin = 6; + /** FastBreak : casses suspectes parmi les 10 dernières mesurées (60 s) avant de compter. */ + public int fastBreakSerieMin = 4; // --- 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 de16e0e..b7d73da 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -475,6 +475,35 @@ public final class Moteur { return verdicts; } + // --- 0.5 (P2) : casse et pose de blocs ------------------------------------------------------------- + + /** START_DESTROY_BLOCK accepté (non annulé par un mod) : début de la mesure fast-break. */ + public void debutCasse(UUID joueur, long tick, int x, int y, int z) { + if (expulses.contains(joueur) || cfg.mode(Controle.FAST_BREAK) == Mode.OFF) return; + suivi(joueur).fastBreak.debut(tick, x, y, z); + } + + /** + * Un bloc vient d'être cassé par le joueur (BlockEvent.BreakEvent). + * + * @param progression {@code getDestroyProgress} du bloc pour ce joueur (par tick) ; NaN si inconnue + */ + public List casseBloc(UUID joueur, long nowMs, long tick, EtatJoueur etat, int x, int y, int z, double progression) { + if (expulses.contains(joueur) || cfg.mode(Controle.FAST_BREAK) == Mode.OFF) return List.of(); + Suivi s = suivi(joueur); + Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE); + if (ex.exempt() || etat.tps() < cfg.tpsLag) { + s.fastBreak.vider(); + return List.of(); + } + double pts = s.fastBreak.casse(nowMs, tick, x, y, z, progression, cfg); + List v = new ArrayList<>(1); + ajouter(v, s, Controle.FAST_BREAK, pts, nowMs, ex, String.format(Locale.ROOT, + "bloc casse a %.2f du temps vanilla (seuil %.2f), %d casses suspectes sur %d", + s.fastBreak.dernierRapport(), cfg.fastBreakFacteur, s.fastBreak.dernierCompte(), FastBreak.SERIE)); + 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/SerieFenetre.java b/src/main/java/com/gastinelgarde/core/SerieFenetre.java new file mode 100644 index 0000000..fc4ea50 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/SerieFenetre.java @@ -0,0 +1,42 @@ +package com.gastinelgarde.core; + +/** + * 0.5 (P2) : série générique « k suspects parmi les n dernières mesures, dans une fenêtre de temps », comme + * {@link SerieCoups} mais sans réglage lu dans la configuration. Tampon de taille fixe, aucune allocation. + */ +public final class SerieFenetre { + + private final int n; + private final long fenetreMs; + private final long[] instants; + private final boolean[] suspects; + private int taille; + private int tete; + + public SerieFenetre(int n, long fenetreMs) { + this.n = Math.max(1, n); + this.fenetreMs = fenetreMs; + this.instants = new long[this.n]; + this.suspects = new boolean[this.n]; + } + + /** Ajoute une mesure ; renvoie le nombre de suspectes parmi les n dernières encore dans la fenêtre. */ + public int ajouter(long nowMs, boolean suspect) { + instants[tete] = nowMs; + suspects[tete] = suspect; + tete = (tete + 1) % n; + if (taille < n) taille++; + int compte = 0; + for (int k = 0; k < taille; k++) { + int i = ((tete - 1 - k) % n + n) % n; + if (nowMs - instants[i] > fenetreMs || instants[i] > nowMs) break; + if (suspects[i]) compte++; + } + return compte; + } + + public void vider() { + taille = 0; + tete = 0; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index 55935a5..918d9d8 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -67,6 +67,8 @@ public final class Suivi { public final AntiFaim antiFaim = new AntiFaim(); /** 0.5 (P2.1) : no-slow. */ public final NoSlow noSlow = new NoSlow(); + /** 0.5 (P2.3) : fast-break. */ + public final FastBreak fastBreak = new FastBreak(); /** 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/FastBreakP2Test.java b/src/test/java/com/gastinelgarde/core/FastBreakP2Test.java new file mode 100644 index 0000000..57feb6f --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/FastBreakP2Test.java @@ -0,0 +1,104 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.UUID; +import org.junit.jupiter.api.Test; + +/** 0.5, P2.3 : fast-break (progression simulée comme ServerPlayerGameMode). */ +class FastBreakP2Test { + + private final GardeConfig cfg = new GardeConfig(); + private final UUID joueur = UUID.randomUUID(); + + /** + * Casse {@code n} blocs successifs (pierre à la pioche en bois : progression 1/15 par tick environ), chacun en + * {@code ticksCasse} ticks après son START. Renvoie le total des points fast-break. + */ + private double casser(Moteur m, EtatJoueur etat, int n, double progression, int ticksCasse) { + double pts = 0; + long tick = 1000; + for (int i = 0; i < n; i++) { + m.debutCasse(joueur, tick, i, 10, 0); + tick += ticksCasse; + for (Verdict v : m.casseBloc(joueur, tick * 50L, tick, etat, i, 10, 0, progression)) { + if (v.controle() == Controle.FAST_BREAK) pts += v.points(); + } + tick += 2; + } + return pts; + } + + @Test + void observeParDefaut() { + assertEquals(Mode.OBSERVE, cfg.mode(Controle.FAST_BREAK)); + assertEquals(Controle.FAST_BREAK, Controle.parse("fast-break")); + assertEquals(2, Controle.FAST_BREAK.fiabilite()); + } + + @Test + void casseALaMargeVanillaEnSerieVue() { + // 15 ticks attendus ; casse à 0,7 : progression × (j + 1) >= 0,7 => j = 10. + double p = 1.0 / 15; + assertTrue(casser(new Moteur(cfg), EtatJoueur.normal(), 10, p, 10) > 0); + } + + @Test + void casseHonneteJamaisVue() { + double p = 1.0 / 15; + assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 50, p, 14), 1e-9); // rapport 1,0 + assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 50, p, 12), 1e-9); // 0,87 : jitter de 2 ticks + } + + @Test + void casseSuspecteIsoleeNeComptePas() { + // 3 suspectes sur 10 (seuil 4) : rien. + Moteur m = new Moteur(cfg); + double p = 1.0 / 15; + double pts = casser(m, EtatJoueur.normal(), 7, p, 14); + pts += casser(m, EtatJoueur.normal(), 3, p, 10); + assertEquals(0, pts, 1e-9); + } + + @Test + void blocsRapidesEtInstantanesNonMesures() { + // 4 ticks attendus (< fastBreakTicksMin 6) et casse instantanée (progression >= 1) : jamais mesurés. + assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 20, 0.25, 1), 1e-9); + assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 20, 1.5, 0), 1e-9); + } + + @Test + void casseSansStartAuMemeEndroitNonMesuree() { + Moteur m = new Moteur(cfg); + double pts = 0; + for (int i = 0; i < 20; i++) { + m.debutCasse(joueur, 100 + i * 20, 0, 0, 0); + for (Verdict v : m.casseBloc(joueur, (110 + i * 20) * 50L, 110 + i * 20, EtatJoueur.normal(), 5, 5, 5, 1.0 / 15)) { + pts += v.points(); + } + } + assertEquals(0, pts, 1e-9); + } + + @Test + void exemptions() { + double p = 1.0 / 15; + for (EtatJoueur e : new EtatJoueur[] { + EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build(), + EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().ticksDepuisGel(10).build(), + EtatJoueur.builder().tps(15).build()}) { + assertEquals(0, casser(new Moteur(cfg), e, 20, p, 10), 1e-9, e.toString()); + } + } + + @Test + void serieFenetreCompteLesDernieres() { + SerieFenetre s = new SerieFenetre(3, 1000); + assertEquals(1, s.ajouter(0, true)); + assertEquals(2, s.ajouter(10, true)); + assertEquals(2, s.ajouter(20, false)); + assertEquals(1, s.ajouter(30, false)); // la première est sortie des 3 dernières + assertEquals(1, s.ajouter(2000, true)); // les autres sont hors fenêtre + } +}