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 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
ee6f0a3cd4
révision
bb1867f07d
8 fichiers modifiés
+188
-4
Aucun fichier ne correspond à votre recherche
@@ -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<Verdict> 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<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);
|
||||
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). */
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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<Verdict> 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<Verdict> 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<Verdict> poseBloc(UUID joueur, long nowMs, long tick, EtatJoueur etat) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.FAST_PLACE) == Mode.OFF) return List.of();
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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. */
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur