P2.10 : nouveau controle xray statistique (alerte seulement)

- core.XrayStats : sur les 400 derniers blocs casses sous xrayAlerteYMax (16),
  au moins xrayRaresMin (12) minerais rares (diamant, debris antiques), plus de
  xrayAlerteDiamantsParCent (5 %) de rares, et au moins
  xrayAlerteNonExposesPart (80 %) de ces rares sans face a l'air, a un fluide
  ou a un bloc non plein au moment de la casse. Fenetre remise a zero apres
  une alerte. Valeurs [A VERIFIER avec les journaux].
- Jamais au-dela de l'ALERTE, meme en ENFORCE (Moteur.ajouter). Creatif et
  spectateur ignores.
- Reglages nouvelle section [xray].
- Tests : XrayP2Test (6). Cablage (BreakEvent, voisins) 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 01:07:05 +02:00
1 Parent 45c1e6e0f0
révision 6a19980656
8 fichiers modifiés
+210 -4

Aucun fichier ne correspond à votre recherche

+15 -1
Voir le fichier
@@ -473,8 +473,12 @@ public final class Garde {
*/
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();
if (CONFIG.mode(Controle.XRAY) != Mode.OFF) { // 0.5 (P2.10) : alerte seulement
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;
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);
@@ -494,6 +498,16 @@ public final class Garde {
return Cablage.sanctionDeMouvement(s);
}
/** 0.5 (P2.10) : une face du bloc touche l'air ou un fluide (minerai visible sans x-ray). */
private static boolean expose(ServerPlayer p, BlockPos pos) {
for (net.minecraft.core.Direction d : net.minecraft.core.Direction.values()) {
BlockPos q = pos.relative(d);
BlockState s = p.level().getBlockState(q);
if (s.isAir() || !p.level().getFluidState(q).isEmpty() || !s.isCollisionShapeFullBlock(p.level(), q)) return true;
}
return false;
}
public static void noterTickServeur(MinecraftServer server, long dureeNs) {
double ms = dureeNs / 1_000_000.0;
if (ms > 250.0) gelTick = server.getTickCount();
+17 -1
Voir le fichier
@@ -30,7 +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, JESUS_TICKS, OMNI_TICKS;
private static final ModConfigSpec.DoubleValue OMNI_ANGLE;
private static final ModConfigSpec.DoubleValue OMNI_ANGLE, XRAY_PCT, XRAY_CACHES;
private static final ModConfigSpec.IntValue XRAY_Y, XRAY_RARES;
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;
@@ -318,6 +319,17 @@ public final class GardeSpec {
.defineInRange("interactionBlocSerieMin", 3, 1, 10);
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);
XRAY_CACHES = b.comment("Part des minerais rares cassés sans face à l'air, à un fluide ou à un bloc non plein.")
.defineInRange("xrayAlerteNonExposesPart", 0.8, 0.0, 1.0);
XRAY_Y = b.comment("Seuls les blocs cassés à cette hauteur ou plus bas comptent.")
.defineInRange("xrayAlerteYMax", 16, -64, 320);
XRAY_RARES = b.comment("Minerais rares dans la fenêtre (400 derniers blocs) avant toute alerte.")
.defineInRange("xrayRaresMin", 12, 1, 400);
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.")
@@ -493,6 +505,10 @@ public final class GardeSpec {
c.jesusTicks = JESUS_TICKS.get();
c.omnisprintAngleDegres = OMNI_ANGLE.get();
c.omnisprintTicks = OMNI_TICKS.get();
c.xrayAlerteDiamantsParCent = XRAY_PCT.get();
c.xrayAlerteNonExposesPart = XRAY_CACHES.get();
c.xrayAlerteYMax = XRAY_Y.get();
c.xrayRaresMin = XRAY_RARES.get();
c.fastBreakFacteur = FAST_BREAK_FACTEUR.get();
c.fastBreakTicksMin = FAST_BREAK_TICKS_MIN.get();
c.fastBreakSerieMin = FAST_BREAK_SERIE.get();
+4 -2
Voir le fichier
@@ -43,7 +43,9 @@ public enum Controle {
/** 0.5 (P2.11) : au sol déclaré sur un fluide, sans bloc ni entité dessous, sans chute (Jesus). */
JESUS("jesus"),
/** 0.5 (P2.14) : sprint en reculant ou de côté, soutenu au sol (Omnisprint). */
OMNISPRINT("omnisprint");
OMNISPRINT("omnisprint"),
/** 0.5 (P2.10) : part anormale de minerais rares non exposés (X-Ray) ; alerte seulement, jamais de sanction. */
XRAY("xray");
private final String id;
@@ -73,7 +75,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 -> 2; // 0.5 (P2) : idem
JESUS, OMNISPRINT, XRAY -> 2; // 0.5 (P2) : idem
};
}
+8
Voir le fichier
@@ -216,6 +216,14 @@ public final class GardeConfig {
public double omnisprintAngleDegres = 100;
/** Omnisprint : paquets consécutifs avant infraction. */
public int omnisprintTicks = 10;
/** X-Ray : part (%) de minerais rares parmi les blocs cassés en profondeur au-delà de laquelle on alerte. */
public double xrayAlerteDiamantsParCent = 5;
/** X-Ray : part des minerais rares cassés sans face à l'air ni à un fluide. */
public double xrayAlerteNonExposesPart = 0.8;
/** X-Ray : seuls les blocs cassés à cette hauteur ou plus bas comptent. */
public int xrayAlerteYMax = 16;
/** X-Ray : minerais rares dans la fenêtre avant toute alerte (un filon chanceux ne suffit pas). */
public int xrayRaresMin = 12;
// --- 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 »). */
+16
Voir le fichier
@@ -517,6 +517,20 @@ public final class Moteur {
return v;
}
/**
* 0.5 (P2.10) : bloc cassé, pour la statistique x-ray (alerte seulement). Pas d'exemption de lag : rien n'y est
* mesuré en temps ; créatif et spectateur exemptés.
*/
public List<Verdict> casseXray(UUID joueur, long nowMs, EtatJoueur etat, int y, boolean rare, boolean expose) {
if (expulses.contains(joueur) || cfg.mode(Controle.XRAY) == Mode.OFF) return List.of();
if (etat.creatif() || etat.spectateur()) return List.of();
Suivi s = suivi(joueur);
List<Verdict> v = new ArrayList<>(1);
double pts = s.xray.casse(y, rare, expose, cfg);
if (pts > 0) ajouter(v, s, Controle.XRAY, pts, nowMs, Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE), s.xray.resume());
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();
@@ -821,6 +835,8 @@ public final class Moteur {
// 0.4.2 (decision de Theo) : vraies sanctions en ENFORCE. Auto-totem n'a pas de retour en arriere qui ait un
// sens : son palier SETBACK reste une ALERTE, l'expulsion s'applique. Velocite : SETBACK = retour en arriere.
if (c == Controle.AUTO_TOTEM && applicable == Sanction.SETBACK) applicable = Sanction.ALERTE;
// 0.5 (P2.10) : x-ray statistique, jamais au-delà de l'alerte (un minage chanceux reste possible).
if (c == Controle.XRAY) applicable = Sanction.min(applicable, Sanction.ALERTE);
s.suspicion.noter(c, vl, palier.ordinal() >= Sanction.SETBACK.ordinal(), horloge.getAsLong());
boolean notifier = applicable.ordinal() >= Sanction.ALERTE.ordinal()
&& s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS);
+2
Voir le fichier
@@ -79,6 +79,8 @@ public final class Suivi {
public final Jesus jesus = new Jesus();
/** 0.5 (P2.14) : omnisprint. */
public final Omnisprint omnisprint = new Omnisprint();
/** 0.5 (P2.10) : x-ray statistique. */
public final XrayStats xray = new XrayStats();
/** 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. */
+76
Voir le fichier
@@ -0,0 +1,76 @@
package com.gastinelgarde.core;
/**
* 0.5 (P2.10) : X-Ray statistique, alerte seulement (jamais de setback ni d'expulsion, même en ENFORCE). Un joueur
* qui voit les minerais à travers la pierre casse une part anormale de minerais rares (diamant, débris antiques) parmi
* les blocs cassés en profondeur, et surtout les atteint sans les avoir vus : le minerai n'a aucune face à l'air ou à un
* fluide au moment de la casse. Un minage en branche honnête trouve ses minerais dans les parois du tunnel (exposés),
* et seul le premier bloc d'un filon peut être caché (les suivants touchent le trou).
*
* Sur les {@link #FENETRE} derniers blocs cassés sous {@link GardeConfig#xrayAlerteYMax} : au moins
* {@link GardeConfig#xrayRaresMin} rares, plus de {@link GardeConfig#xrayAlerteDiamantsParCent} % de rares, et une part
* de rares non exposés d'au moins {@link GardeConfig#xrayAlerteNonExposesPart}. Après une alerte, la fenêtre repart de
* zéro. Valeurs prudentes [À VÉRIFIER avec les journaux] : un filon chanceux ne suffit pas (seuil de rares).
*/
public final class XrayStats {
public static final int FENETRE = 400;
/** 0 = bloc ordinaire, 1 = rare exposé, 2 = rare non exposé. */
private final byte[] blocs = new byte[FENETRE];
private int taille;
private int tete;
private int rares;
private int caches;
/** Un bloc cassé. @param y hauteur ; @param rare minerai rare ; @param expose une face à l'air ou à un fluide */
public double casse(int y, boolean rare, boolean expose, GardeConfig cfg) {
if (y > cfg.xrayAlerteYMax) return 0;
byte v = (byte) (rare ? (expose ? 1 : 2) : 0);
if (taille == FENETRE) {
byte ancien = blocs[tete];
if (ancien > 0) rares--;
if (ancien == 2) caches--;
} else {
taille++;
}
blocs[tete] = v;
tete = (tete + 1) % FENETRE;
if (v > 0) rares++;
if (v == 2) caches++;
if (!rare || rares < Math.max(1, cfg.xrayRaresMin)) return 0;
boolean taux = rares * 100.0 / taille > cfg.xrayAlerteDiamantsParCent;
boolean masques = partCachee() >= cfg.xrayAlerteNonExposesPart;
if (!taux || !masques) return 0;
resume = String.format(java.util.Locale.ROOT, "%d minerais rares sur %d blocs casses sous y=%d, %.0f %% non exposes",
rares, taille, cfg.xrayAlerteYMax, partCachee() * 100);
vider();
return 2.0;
}
private String resume = "";
/** Résumé de la dernière alerte (pour le journal). */
public String resume() {
return resume;
}
public int rares() {
return rares;
}
public int taille() {
return taille;
}
public double partCachee() {
return rares == 0 ? 0 : (double) caches / rares;
}
public void vider() {
taille = 0;
tete = 0;
rares = 0;
caches = 0;
}
}
+72
Voir le fichier
@@ -0,0 +1,72 @@
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.10 : x-ray statistique (alerte seulement). */
class XrayP2Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
/** n blocs cassés à y = -50 ; tous les k blocs un rare, exposé ou non. */
private double miner(Moteur m, EtatJoueur e, int n, int k, boolean expose) {
double pts = 0;
for (int i = 1; i <= n; i++) {
boolean rare = i % k == 0;
for (Verdict v : m.casseXray(joueur, i * 1000L, e, -50, rare, expose)) {
pts += v.points();
assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal());
}
}
return pts;
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.XRAY));
}
@Test
void mineraisCachesEnSerieAlerte() {
// 1 rare caché tous les 10 blocs (10 %) : alerte au 12e.
assertTrue(miner(new Moteur(cfg), EtatJoueur.normal(), 200, 10, false) > 0);
}
@Test
void minageHonneteJamaisAlerte() {
// Minerais trouvés dans les parois (exposés), même à 10 %.
assertEquals(0, miner(new Moteur(cfg), EtatJoueur.normal(), 2000, 10, true), 1e-9);
// Minerais cachés mais rares (1 %, minage en branche).
assertEquals(0, miner(new Moteur(cfg), EtatJoueur.normal(), 2000, 100, false), 1e-9);
}
@Test
void unFilonChanceuxNeSuffitPas() {
Moteur m = new Moteur(cfg);
double pts = 0;
for (int i = 0; i < 8; i++) pts += m.casseXray(joueur, i, EtatJoueur.normal(), -50, true, false).stream().mapToDouble(Verdict::points).sum();
assertEquals(0, pts, 1e-9);
}
@Test
void enSurfaceEtCreatifRien() {
Moteur m = new Moteur(cfg);
double pts = 0;
for (int i = 0; i < 100; i++) pts += m.casseXray(joueur, i, EtatJoueur.normal(), 60, true, false).size();
assertEquals(0, pts, 1e-9);
assertEquals(0, miner(new Moteur(cfg), EtatJoueur.builder().creatif(true).build(), 200, 10, false), 1e-9);
}
@Test
void jamaisDeSanctionMemeEnEnforce() {
cfg.mode(Controle.XRAY, Mode.ENFORCE);
cfg.seuilAlerte = 0.5;
cfg.seuilSetback = 1;
cfg.seuilExpulsion = 1.5;
assertTrue(miner(new Moteur(cfg), EtatJoueur.normal(), 400, 10, false) > 0); // l'assertion ≤ ALERTE est dans miner
}
}