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 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
9652b48ea6
révision
fad4da8f7c
9 fichiers modifiés
+210
-2
Aucun fichier ne correspond à votre recherche
@@ -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<Verdict> 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();
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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 »). */
|
||||
|
||||
@@ -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<Verdict> 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<Verdict> 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.
|
||||
|
||||
@@ -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. */
|
||||
|
||||
@@ -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());
|
||||
}
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur