P2.3 : nouveau controle fast-break (OBSERVE par defaut)

- core.FastBreak : a la casse (BlockEvent.BreakEvent) d'un bloc dont le START
  a ete vu au meme endroit, rapport = getDestroyProgress x (ticks + 1). Vanilla
  (ServerPlayerGameMode.handleBlockBreakAction, verifie dans les sources
  NeoForge 21.1.234) accepte des 0,7 ; suspect sous fastBreakFacteur (0,8).
- Points seulement en serie : fastBreakSerieMin (4) casses suspectes sur les
  10 dernieres mesurees en 60 s. Pas de mesure : blocs < fastBreakTicksMin (6)
  ticks, casse instantanee, START ailleurs, creatif/spectateur, contraption et
  vaisseau Sable, gel du serveur, TPS bas, connexion recente.
- Exemptions.Famille.MONDE (casse et pose de blocs) ; core.SerieFenetre (serie
  generique k sur n dans une fenetre).
- En ENFORCE au palier SETBACK la casse est annulee ; expulsion comme ailleurs.
- P2.2 FastEat/FastBow : rien a coder, l'usage d'objet est compte par le
  serveur (LivingEntity.updateUsingItem, tick du joueur par le serveur).
- Reglages [monde] : fastBreakFacteur, fastBreakTicksMin, fastBreakSerieMin.
- Tests : FastBreakP2Test (8). Cablage non teste en jeu.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Sonnet 5.5 a révisé 2026-10-24 00:49:49 +02:00
1 Parent c49cf985d8
révision 9652b48ea6
11 fichiers modifiés
+318 -3

Aucun fichier ne correspond à votre recherche

+22
Voir le fichier
@@ -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<Verdict> 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();
+15
Voir le fichier
@@ -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) {
+15
Voir le fichier
@@ -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();
+4 -2
Voir le fichier
@@ -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
};
}
+8 -1
Voir le fichier
@@ -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
+71
Voir le fichier
@@ -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;
}
}
+6
Voir le fichier
@@ -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 »). */
+29
Voir le fichier
@@ -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<Verdict> 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<Verdict> 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.
+42
Voir le fichier
@@ -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;
}
}
+2
Voir le fichier
@@ -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. */
+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.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
}
}