From bb1867f07d3f0174a956c5690593bd70837da93f Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Sat, 24 Oct 2026 03:07:18 +0200 Subject: [PATCH] P3.3 : nouveau controle nuker (OBSERVE par defaut) - Signal : blocs casses par le joueur dans un meme tick serveur (BlockEvent.BreakEvent). Client vanilla (MultiPlayerGameMode, sources NeoForge 21.1.234) : une casse au plus par tick client, destroyDelay 5 apres un bloc non instantane. - Plafond nukerBlocsParTickMax = 3 (gigue : ticks client groupes), points seulement en serie : nukerSerieMin = 3 ticks suspects parmi les 20 derniers ticks de casse (60 s). Section [p3] de la config. - Exemptions famille MONDE (creatif, spectateur, contraption Create, vaisseau Sable, gel serveur) et TPS bas (pas de mesure). - En ENFORCE au palier SETBACK la casse est annulee ; l'expulsion comme ailleurs. - A verifier avant ENFORCE : un mod serveur d'abattage / minage de filon casse aussi plusieurs blocs au nom du joueur. - Tests : NukerP3Test (7). Co-Authored-By: Claude Sonnet 5.5 --- src/main/java/com/gastinelgarde/Garde.java | 14 +++- .../java/com/gastinelgarde/GardeSpec.java | 13 ++++ .../java/com/gastinelgarde/core/Controle.java | 6 +- .../com/gastinelgarde/core/GardeConfig.java | 6 ++ .../java/com/gastinelgarde/core/Moteur.java | 20 +++++ .../java/com/gastinelgarde/core/Nuker.java | 56 ++++++++++++++ .../java/com/gastinelgarde/core/Suivi.java | 2 + .../com/gastinelgarde/core/NukerP3Test.java | 75 +++++++++++++++++++ 8 files changed, 188 insertions(+), 4 deletions(-) create mode 100644 src/main/java/com/gastinelgarde/core/Nuker.java create mode 100644 src/test/java/com/gastinelgarde/core/NukerP3Test.java diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index fd44e2a..7f55eb3 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -483,13 +483,23 @@ public final class Garde { boolean rare = state.is(Blocks.DIAMOND_ORE) || state.is(Blocks.DEEPSLATE_DIAMOND_ORE) || state.is(Blocks.ANCIENT_DEBRIS); traiter(p, MOTEUR.casseXray(p.getUUID(), tick * 50L, etat(p, false), pos.getY(), rare, rare && expose(p, pos))); } - if (CONFIG.mode(Controle.FAST_BREAK) == Mode.OFF) return false; + boolean annulerNuker = false; + if (CONFIG.mode(Controle.NUKER) != Mode.OFF) { // 0.5 (P3.3) + List vn = MOTEUR.casseNuker(p.getUUID(), tick * 50L, tick, etat(p, true)); + Sanction sn = traiter(p, vn); + if (sn == Sanction.EXPULSION) { + appliquerSanctionMouvement(p, sn, vn); + return true; + } + annulerNuker = Cablage.sanctionDeMouvement(sn); + } + if (CONFIG.mode(Controle.FAST_BREAK) == Mode.OFF) return annulerNuker; 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); + return annulerNuker || 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). */ diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index 54c5e17..9b382bd 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -37,6 +37,8 @@ public final class GardeSpec { private static final ModConfigSpec.IntValue FAST_PLACE_SERIE, FAST_PLACE_INTERVALLE; private static final ModConfigSpec.DoubleValue FAST_PLACE_REGULARITE, INTER_MARGE; private static final ModConfigSpec.IntValue INTER_SERIE, TOTEM_ECHANT, TOTEM_ECART, TOTEM_REG_MAX; + // 0.5 (P3) + private static final ModConfigSpec.IntValue NUKER_MAX, NUKER_SERIE; private static final ModConfigSpec.DoubleValue ANGLE_MAX; private static final ModConfigSpec.IntValue CIBLES_MAX; @@ -319,6 +321,15 @@ public final class GardeSpec { .defineInRange("interactionBlocSerieMin", 3, 1, 10); b.pop(); + b.comment("0.5 (P3) : contrôles lourds. Nouveaux contrôles en OBSERVE par défaut, valeurs prudentes.").push("p3"); + NUKER_MAX = b.comment("0.5 (P3.3) nuker : blocs cassés par un joueur dans un même tick serveur au-delà desquels le tick est suspect.", + "Vanilla : 1 par tick client ; 3 couvre les paquets groupés par la gigue réseau. Un mod d'abattage / de minage de filon", + "côté serveur casse aussi plusieurs blocs au nom du joueur : à vérifier avant tout ENFORCE.") + .defineInRange("nukerBlocsParTickMax", 3, 1, 64); + NUKER_SERIE = b.comment("Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter.") + .defineInRange("nukerSerieMin", 3, 1, 20); + b.pop(); + b.comment("0.5 (P2.10) x-ray statistique : alerte seulement, jamais de setback ni d'expulsion (même en ENFORCE).").push("xray"); XRAY_PCT = b.comment("Part (%) de minerais rares (diamant, débris antiques) parmi les blocs cassés en profondeur au-delà de laquelle on alerte.") .defineInRange("xrayAlerteDiamantsParCent", 5.0, 0.5, 100.0); @@ -520,6 +531,8 @@ public final class GardeSpec { c.autoTotemEchantillons = TOTEM_ECHANT.get(); c.autoTotemEcartTypeMinMs = TOTEM_ECART.get(); c.autoTotemRegulierMaxMs = TOTEM_REG_MAX.get(); + c.nukerBlocsParTickMax = NUKER_MAX.get(); + c.nukerSerieMin = NUKER_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 f06138f..0bb9cd5 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -45,7 +45,9 @@ public enum Controle { /** 0.5 (P2.14) : sprint en reculant ou de côté, soutenu au sol (Omnisprint). */ OMNISPRINT("omnisprint"), /** 0.5 (P2.10) : part anormale de minerais rares non exposés (X-Ray) ; alerte seulement, jamais de sanction. */ - XRAY("xray"); + XRAY("xray"), + /** 0.5 (P3.3) : plusieurs blocs cassés dans le même tick serveur, en série (Nuker). */ + NUKER("nuker"); private final String id; @@ -75,7 +77,7 @@ public enum Controle { // 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, FAST_PLACE, INTERACTION_BLOC, AUTO_TOTEM_REGULIER, - JESUS, OMNISPRINT, XRAY -> 2; // 0.5 (P2) : idem + JESUS, OMNISPRINT, XRAY, NUKER -> 2; // 0.5 (P2) : idem }; } diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index b67cf59..9ee884c 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -225,6 +225,12 @@ public final class GardeConfig { /** X-Ray : minerais rares dans la fenêtre avant toute alerte (un filon chanceux ne suffit pas). */ public int xrayRaresMin = 12; + // --- 0.5 (P3) : nouveaux contrôles, OBSERVE par défaut, valeurs prudentes à valider en jeu --- + /** Nuker : blocs cassés dans un même tick serveur au-delà desquels le tick est suspect (vanilla : 1, gigue comprise : 3). */ + public int nukerBlocsParTickMax = 3; + /** Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter. */ + public int nukerSerieMin = 3; + // --- 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 »). */ public boolean diagnosticActionsBloc = true; diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index e939fe2..f675c69 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -531,6 +531,26 @@ public final class Moteur { return v; } + /** + * 0.5 (P3.3) : bloc cassé par le joueur, pour le nuker (plusieurs blocs dans le même tick serveur). Exemptions de la + * famille MONDE (créatif, spectateur, contraption, vaisseau, gel) ; TPS bas : pas de mesure (paquets groupés). + */ + public List casseNuker(UUID joueur, long nowMs, long tick, EtatJoueur etat) { + if (expulses.contains(joueur) || cfg.mode(Controle.NUKER) == 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.nuker.vider(); + return List.of(); + } + double pts = s.nuker.casse(nowMs, tick, cfg); + List v = new ArrayList<>(1); + ajouter(v, s, Controle.NUKER, pts, nowMs, ex, String.format(Locale.ROOT, + "%d blocs casses dans le meme tick (max %d), %d ticks suspects sur %d", s.nuker.casses(), + cfg.nukerBlocsParTickMax, s.nuker.dernierCompte(), Nuker.SERIE)); + 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(); diff --git a/src/main/java/com/gastinelgarde/core/Nuker.java b/src/main/java/com/gastinelgarde/core/Nuker.java new file mode 100644 index 0000000..50719c7 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/Nuker.java @@ -0,0 +1,56 @@ +package com.gastinelgarde.core; + +/** + * 0.5 (P3.3) : Nuker (casse de plusieurs blocs par tick). Client vanilla 1.21.1 (MultiPlayerGameMode, vérifié dans les + * sources NeoForge 21.1.234) : une casse au plus par tick client, puis {@code destroyDelay = 5} ticks après un bloc qui + * n'est pas instantané ; même les blocs instantanés (herbe, fleurs) ne partent qu'un par tick au clic maintenu. + * + * Signal : nombre de blocs cassés par le joueur pendant un même tick serveur (BlockEvent.BreakEvent). Des paquets de + * deux ou trois ticks client peuvent arriver groupés dans un tick serveur (gigue réseau) : le plafond + * {@link GardeConfig#nukerBlocsParTickMax} (3) le couvre ; un Nuker en casse en général des dizaines. Points seulement en + * série : {@link GardeConfig#nukerSerieMin} ticks au-delà du plafond parmi les {@link #SERIE} derniers ticks de casse + * (60 s). Un mod serveur qui casse plusieurs blocs « au nom » du joueur (abattage d'arbre, minage de filon) déclenche + * aussi BreakEvent : [À VÉRIFIER] sur la liste des mods du serveur ; OBSERVE par défaut. + */ +public final class Nuker { + + public static final int SERIE = 20; + public static final long FENETRE_MS = 60_000; + + private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS); + private long tickCourant = Long.MIN_VALUE; + private int casses; + private boolean signale; + private int dernierCompte; + + /** Un bloc cassé au tick serveur donné. @return points d'infraction */ + public double casse(long nowMs, long tick, GardeConfig cfg) { + if (tick != tickCourant) { + tickCourant = tick; + casses = 0; + signale = false; + dernierCompte = serie.ajouter(nowMs, false); // un tick de casse ordinaire + } + casses++; + if (signale || casses <= Math.max(1, cfg.nukerBlocsParTickMax)) return 0; + signale = true; // un tick suspect compté une fois + dernierCompte = serie.ajouter(nowMs, true); + if (dernierCompte < Math.max(1, cfg.nukerSerieMin)) return 0; + return 2.0; + } + + public int casses() { + return casses; + } + + public int dernierCompte() { + return dernierCompte; + } + + public void vider() { + serie.vider(); + tickCourant = Long.MIN_VALUE; + casses = 0; + signale = false; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index 9d1c7d8..ca1b42d 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -81,6 +81,8 @@ public final class Suivi { public final Omnisprint omnisprint = new Omnisprint(); /** 0.5 (P2.10) : x-ray statistique. */ public final XrayStats xray = new XrayStats(); + /** 0.5 (P3.3) : nuker. */ + public final Nuker nuker = new Nuker(); /** 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/NukerP3Test.java b/src/test/java/com/gastinelgarde/core/NukerP3Test.java new file mode 100644 index 0000000..9480ed9 --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/NukerP3Test.java @@ -0,0 +1,75 @@ +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, P3.3 : nuker (blocs cassés dans un même tick serveur). */ +class NukerP3Test { + + private final GardeConfig cfg = new GardeConfig(); + private final UUID joueur = UUID.randomUUID(); + + /** casses[i] blocs au tick 100 + i * pas. */ + private double casser(Moteur m, EtatJoueur etat, int pas, int... casses) { + double pts = 0; + for (int i = 0; i < casses.length; i++) { + long t = 100 + (long) i * pas; + for (int k = 0; k < casses[i]; k++) { + for (Verdict v : m.casseNuker(joueur, t * 50L, t, etat)) { + if (v.controle() == Controle.NUKER) pts += v.points(); + } + } + } + return pts; + } + + @Test + void observeParDefaut() { + assertEquals(Mode.OBSERVE, cfg.mode(Controle.NUKER)); + assertEquals(Controle.NUKER, Controle.parse("nuker")); + assertEquals(2, Controle.NUKER.fiabilite()); + } + + @Test + void nukerDeVingtBlocsParTickVu() { + assertTrue(casser(new Moteur(cfg), EtatJoueur.normal(), 5, 20, 20, 20, 20) > 0); + } + + @Test + void uneCasseParTickJamaisVue() { + int[] c = new int[400]; + java.util.Arrays.fill(c, 1); + assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 1, c), 1e-9); + } + + @Test + void paquetsGroupesParLaGigueTolere() { + // Herbe fauchée au clic maintenu, ticks client groupés par deux ou trois : jamais au-delà du plafond. + int[] c = new int[300]; + for (int i = 0; i < c.length; i++) c[i] = 1 + i % 3; + assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 2, c), 1e-9); + } + + @Test + void unSeulTickSuspectNeSuffitPas() { + assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 5, 1, 1, 8, 1, 1, 1, 1), 1e-9); + } + + @Test + void exemptions() { + for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(), + EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().pocheContraption(true).build(), + EtatJoueur.builder().ticksDepuisGel(3).build(), EtatJoueur.builder().tps(12).build()}) { + assertEquals(0, casser(new Moteur(cfg), e, 5, 20, 20, 20, 20, 20), 1e-9, e.toString()); + } + } + + @Test + void desactive() { + cfg.mode(Controle.NUKER, Mode.OFF); + assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 5, 20, 20, 20, 20), 1e-9); + } +}