Fichiers
gastinel-garde/src/main/java/com/gastinelgarde/GardeSpec.java
T
gastineltetClaude Opus 5.5 7a5a1c92c8 GastinelGarde #92 : controle coups-hors-boite (historique des boites des cibles)
Le test hitbox/portee de Rednixxu passait sous portee et hitbox : sur une cible
qui bouge, la marge vitesse x ticks (plafond 1,0 bloc) noyait tout. Nouveau
controle : regard et distance testes contre les boites reellement occupees
par la cible pendant la fenetre d affichage (7 ticks + ping), serie de 4 coups
hors boite sur 10. OBSERVE par defaut.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 00:55:31 +02:00

354 lignes
21 KiB
Java
Brut Annotations Historique

Ce fichier contient des caractères Unicode ambigus.
Ce fichier contient des caractères Unicode qui peuvent être confondus avec d'autres caractères. Si vous pensez que c'est intentionnel, vous pouvez ignorer cet avertissement. Utilisez le bouton Échappe pour les dévoiler.
package com.gastinelgarde;
import com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.GardeConfig;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Sanction;
import java.util.EnumMap;
import java.util.Map;
import net.neoforged.fml.event.config.ModConfigEvent;
import net.neoforged.neoforge.common.ModConfigSpec;
/** Fichier de configuration (NeoForge) et recopie vers la configuration du moteur. */
public final class GardeSpec {
public static final ModConfigSpec SPEC;
private static final Map<Controle, ModConfigSpec.EnumValue<Mode>> MODES = new EnumMap<>(Controle.class);
private static final ModConfigSpec.DoubleValue VL_DECROISSANCE;
private static final ModConfigSpec.DoubleValue SEUIL_ALERTE;
private static final ModConfigSpec.DoubleValue SEUIL_SETBACK;
private static final ModConfigSpec.DoubleValue SEUIL_EXPULSION;
private static final ModConfigSpec.EnumValue<Sanction> SANCTION_MAX;
private static final ModConfigSpec.DoubleValue ANGLE_MAX;
private static final ModConfigSpec.IntValue CIBLES_MAX;
private static final ModConfigSpec.IntValue FENETRE_CIBLES_MS;
private static final ModConfigSpec.IntValue CPS_MAX;
private static final ModConfigSpec.DoubleValue ECART_TYPE_MIN;
private static final ModConfigSpec.DoubleValue INTERVALLE_MOYEN_MAX;
private static final ModConfigSpec.IntValue PAQUETS_PAR_SECONDE;
private static final ModConfigSpec.IntValue TIMER_SECONDES;
private static final ModConfigSpec.DoubleValue EXCES_VITESSE;
private static final ModConfigSpec.IntValue GRACE_TELEPORT;
private static final ModConfigSpec.IntValue GRACE_RECUL;
private static final ModConfigSpec.IntValue GRACE_GEL;
private static final ModConfigSpec.DoubleValue TPS_LAG;
private static final ModConfigSpec.IntValue PING_LAG;
private static final ModConfigSpec.DoubleValue FACTEUR_LAG;
private static final ModConfigSpec.DoubleValue PORTEE_TOLERANCE;
private static final ModConfigSpec.DoubleValue HITBOX_MARGE;
private static final ModConfigSpec.IntValue TICKS_LATENCE_CIBLE;
private static final ModConfigSpec.DoubleValue LATENCE_CIBLE_MAX;
private static final ModConfigSpec.IntValue PING_LATENCE_MAX;
private static final ModConfigSpec.DoubleValue VITESSE_CIBLE_MAX;
private static final ModConfigSpec.IntValue TICKS_AFFICHAGE;
private static final ModConfigSpec.IntValue SERIE_PING_MAX;
private static final ModConfigSpec.DoubleValue SERIE_MANQUE;
private static final ModConfigSpec.DoubleValue SERIE_PORTEE;
private static final ModConfigSpec.IntValue SERIE_COUPS;
private static final ModConfigSpec.IntValue SERIE_HORS_MIN;
private static final ModConfigSpec.IntValue SERIE_FENETRE_MS;
private static final ModConfigSpec.DoubleValue SERIE_POINTS;
private static final ModConfigSpec.ConfigValue<String> PREFIXES_CONTRAPTION;
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
private static final ModConfigSpec.ConfigValue<String> BLOCS_COURANT_AIR;
private static final ModConfigSpec.IntValue DISTANCE_COURANT_AIR;
private static final ModConfigSpec.ConfigValue<String> BLOCS_ENTRAINEMENT;
private static final ModConfigSpec.BooleanValue AC_ACTIF;
private static final ModConfigSpec.DoubleValue AC_VITESSE_MAX;
private static final ModConfigSpec.DoubleValue AC_FACTEUR_SUPPRESSION;
private static final ModConfigSpec.DoubleValue AC_MARGE_BORDURE;
private static final ModConfigSpec.BooleanValue AC_ALERTES_OPS;
private static final ModConfigSpec.DoubleValue AC_VITESSE_MINECART;
private static final ModConfigSpec.IntValue AC_EMPILEMENT_MAX;
private static final ModConfigSpec.BooleanValue TRACES_ACTIVES;
private static final ModConfigSpec.IntValue TRACES_JOURS;
private static final ModConfigSpec.IntValue TRACES_TAILLE_MO;
static {
ModConfigSpec.Builder b = new ModConfigSpec.Builder();
b.comment("Mode de chaque contrôle : OFF (coupé), OBSERVE (journal et message aux ops, aucune sanction),",
"ENFORCE (sanctions appliquées). Tout démarre en OBSERVE ; ne passer en ENFORCE qu'après",
"plusieurs jours sans fausse alerte sur des joueurs honnêtes.",
"no-fall, vitesse, vol, portee et hitbox : OBSERVE conseillé tant qu'ils n'ont pas été validés en jeu.").push("modes");
for (Controle c : Controle.values()) {
MODES.put(c, b.defineEnum(c.id(), Mode.OBSERVE));
}
b.pop();
b.push("sanctions");
VL_DECROISSANCE = b.comment("Points d'infraction perdus par seconde (par contrôle). S'applique aux joueurs qui se connectent après le rechargement.")
.defineInRange("decroissanceParSeconde", 0.5, 0.0, 100.0);
SEUIL_ALERTE = b.defineInRange("seuilAlerte", 5.0, 0.1, 1000.0);
SEUIL_SETBACK = b.defineInRange("seuilSetback", 10.0, 0.1, 1000.0);
SEUIL_EXPULSION = b.defineInRange("seuilExpulsion", 20.0, 0.1, 1000.0);
SANCTION_MAX = b.comment("Sanction la plus forte autorisée : JOURNAL, ALERTE, SETBACK ou EXPULSION. Il n'y a jamais de bannissement automatique.")
.defineEnum("sanctionMax", Sanction.EXPULSION);
b.pop();
b.push("combat");
ANGLE_MAX = b.comment("Excédent d'angle maximal entre le regard et la silhouette de la cible (degrés).")
.defineInRange("angleMaxDegres", 60.0, 5.0, 180.0);
CIBLES_MAX = b.defineInRange("ciblesMax", 3, 1, 20);
FENETRE_CIBLES_MS = b.defineInRange("fenetreCiblesMs", 1000, 100, 10000);
CPS_MAX = b.comment("Coups par seconde, soutenus 2 s, au-delà desquels on lève une infraction.")
.defineInRange("cpsMax", 20, 5, 100);
ECART_TYPE_MIN = b.defineInRange("ecartTypeMinMs", 12.0, 0.0, 100.0);
INTERVALLE_MOYEN_MAX = b.defineInRange("intervalleMoyenMaxMs", 150.0, 20.0, 1000.0);
PORTEE_TOLERANCE = b.comment("Portée : marge (blocs) au-delà de la portée d'interaction du joueur (3,0 en survie).",
"Vanilla refuse déjà tout coup à plus de portée + 1,0 bloc : ce contrôle couvre la bande intermédiaire.")
.defineInRange("porteeToleranceBlocs", 0.3, 0.0, 2.0);
HITBOX_MARGE = b.comment("Hitbox : de combien (blocs) la boîte réelle de la cible peut manquer le regard.")
.defineInRange("hitboxMargeBlocs", 0.25, 0.0, 2.0);
TICKS_LATENCE_CIBLE = b.comment("Retard d'affichage de la cible chez le client (ticks), multiplié par sa vitesse.")
.defineInRange("ticksLatenceCible", 3, 0, 20);
LATENCE_CIBLE_MAX = b.defineInRange("latenceCibleMaxBlocs", 1.0, 0.0, 4.0);
PING_LATENCE_MAX = b.comment("Ping (ms) au plus ajouté au retard d affichage de la cible (ping / 50 ticks), plafonné par latenceCibleMaxBlocs.")
.defineInRange("pingLatenceMaxMs", 300, 0, 1000);
VITESSE_CIBLE_MAX = b.comment("Cible plus rapide (blocs/tick) : portée et hitbox ne mesurent pas (élytres, recul, téléportation).")
.defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
b.pop();
b.comment("Contrôle coups-hors-boite (#92) : le regard est testé contre toutes les positions où le client a pu",
"voir la cible (historique des boîtes), au lieu d'une marge « vitesse × ticks » dans toutes les directions.",
"Un coup isolé ne compte pas : seulement une série (serieHorsMin coups hors boîte sur les serieCoups derniers).",
"Valeurs de départ prudentes, à régler avec les journaux en OBSERVE avant tout ENFORCE.").push("coupsHorsBoite");
TICKS_AFFICHAGE = b.comment("Retard d'affichage de base de la cible chez le client (ticks) ; le ping s'ajoute (ping / 50).")
.defineInRange("ticksAffichageCible", 7, 2, 12);
SERIE_PING_MAX = b.comment("Ping (ms) au-delà duquel le coup n'est pas mesuré.")
.defineInRange("seriePingMaxMs", 500, 100, 500);
SERIE_MANQUE = b.comment("Coup hors boîte si le regard manque toutes les boîtes vues de plus de cette marge (blocs).")
.defineInRange("serieManqueBlocs", 0.15, 0.05, 2.0);
SERIE_PORTEE = b.comment("... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs).")
.defineInRange("seriePorteeMargeBlocs", 0.15, 0.05, 2.0);
SERIE_COUPS = b.defineInRange("serieCoups", 10, 3, 32);
SERIE_HORS_MIN = b.defineInRange("serieHorsMin", 4, 2, 32);
SERIE_FENETRE_MS = b.defineInRange("serieFenetreMs", 30000, 1000, 600000);
SERIE_POINTS = b.defineInRange("seriePoints", 2.0, 0.1, 20.0);
b.pop();
b.push("timer");
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
b.pop();
b.push("mouvement");
EXCES_VITESSE = b.comment("Total d'excès de vitesse horizontale (blocs) sur 20 ticks avant une infraction.",
"Valeurs de départ généreuses, à resserrer avec les traces réelles.")
.defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0);
b.pop();
b.push("exemptions");
GRACE_TELEPORT = b.defineInRange("graceTeleportTicks", 40, 0, 600);
GRACE_RECUL = b.defineInRange("graceReculTicks", 20, 0, 600);
GRACE_GEL = b.defineInRange("graceGelTicks", 100, 0, 1200);
TPS_LAG = b.defineInRange("tpsLag", 18.0, 1.0, 20.0);
PING_LAG = b.comment("Ignoré depuis 0.3.0 : le ping est falsifiable par le client (PingSpoof). Gardé pour compatibilité.")
.defineInRange("pingLagMs", 250, 50, 5000);
FACTEUR_LAG = b.comment("Multiplicateur des seuils quand le serveur tire (TPS sous tpsLag, mesuré par le serveur).")
.defineInRange("facteurLag", 1.5, 1.0, 5.0);
PREFIXES_CONTRAPTION = b.comment("Classes (séparées par des virgules) des entités de contraption ; les sous-classes sont couvertes.",
"Un nom finissant par une minuscule, « . » ou « * » est un préfixe de paquet. Un joueur près d'une telle entité est exempté.",
"Les vaisseaux Aeronautics ne sont pas des entités : ils sont détectés par Sable, indépendamment de ce réglage (voir README).")
.define("prefixesContraption", com.gastinelgarde.core.DetectionContraption.MOTIFS_DEFAUT);
DISTANCE_CONTRAPTION = b.defineInRange("distanceContraptionBlocs", 3, 0, 16);
BLOCS_COURANT_AIR = b.comment("Blocs (identifiants séparés par des virgules) qui soufflent un courant d'air le long d'un axe",
"(ventilateur Create : il porte et pousse les joueurs, côté client seulement). Un joueur dans l'axe d'un tel bloc,",
"à au plus distanceCourantAirBlocs sans bloc plein entre les deux, n'est contrôlé ni en vitesse ni en vol (15/10/2026).")
.define("blocsCourantAir", "create:encased_fan");
DISTANCE_COURANT_AIR = b.comment("Portée du courant d'air (blocs). 0 = pas de détection. Create : 20 par défaut.")
.defineInRange("distanceCourantAirBlocs", 24, 0, 64);
BLOCS_ENTRAINEMENT = b.comment("Blocs qui entraînent le joueur posé dessus (tapis roulant Create) : vitesse non contrôlée.")
.define("blocsEntrainement", "create:belt");
b.pop();
b.comment("Anti-crash des entités non joueurs (incident du 16/10/2026 : œuf lancé à ~1e53 blocs/tick, génération",
"de chunks à Z = 2 147 483 500, serveur planté). Ce n'est pas un contrôle de triche : pas de mode OBSERVE,",
"il agit dès qu'il est actif. Les joueurs ne sont jamais concernés (riptide, élytres) ; les contraptions",
"Create, les entités sur un vaisseau Sable et les véhicules qui portent un joueur ne sont jamais supprimés",
"(seulement arrêtés).").push("antiCrash");
AC_ACTIF = b.define("actif", true);
AC_VITESSE_MAX = b.comment("Vitesse maximale (blocs/tick) d'une entité non joueur ; au-delà elle est ramenée à cette valeur.",
"100 = 2 000 blocs/s : plus de 25 fois le projectile vanilla le plus rapide (flèche d'arbalète ~3,2),",
"50 fois un bateau sur glace bleue (~2), largement au-dessus des canons à TNT courants et des trains Create.",
"Un rayon de 100 blocs touche au plus ~8 chunks par tick.")
.defineInRange("vitesseMaxBlocsParTick", 100.0, 4.0, 10000.0);
AC_FACTEUR_SUPPRESSION = b.comment("Au-delà de vitesseMax × ce facteur (1 000 blocs/tick par défaut), l'entité est supprimée au lieu d'être ralentie.")
.defineInRange("facteurSuppression", 10.0, 1.0, 1000.0);
AC_MARGE_BORDURE = b.comment("Marge (blocs) au-delà de la bordure du monde : une entité (ou sa trajectoire du tick) plus loin est supprimée.",
"Les limites absolues du jeu (±30 000 000 horizontal, ±20 000 000 vertical) s'appliquent toujours.")
.defineInRange("margeBordureBlocs", 64.0, 0.0, 1000000.0);
AC_VITESSE_MINECART = b.comment("Vitesse maximale d'un minecart (blocs/tick). Vanilla 1.21.1 : 0,4 sur rail (NeoForge jusqu'à 1,2),",
"vitesse ramenée à 2,0 au plus sur rail, 0,4 hors rail. 3,0 laisse de la marge (Create, canons). Exploit",
"d'empilement : la vitesse des minecarts superposés croît exponentiellement et passe à leurs projectiles.")
.defineInRange("vitesseMaxMinecartBlocsParTick", 3.0, 0.5, 100.0);
AC_EMPILEMENT_MAX = b.comment("Minecarts au plus qui se chevauchent : au-delà, leur poussée mutuelle est coupée et les",
"excédentaires (sans passager) sont cassés et lâchent leur objet. 0 = pas de limite.")
.defineInRange("minecartsSuperposesMax", 4, 0, 64);
AC_ALERTES_OPS = b.comment("Message aux ops (5 au plus par 10 s ; tout est dans logs/gastinelgarde.log).")
.define("alertesOps", true);
b.pop();
b.comment("Enregistreur de traces JSONL (une ligne par mouvement et par coup). Données personnelles : positions des joueurs.")
.push("traces");
TRACES_ACTIVES = b.comment("Enregistrement continu pour tous les joueurs (décision T7 de Théo, 13/10/2026).")
.define("actives", true);
TRACES_JOURS = b.defineInRange("joursConservation", 7, 1, 90);
TRACES_TAILLE_MO = b.defineInRange("tailleMaxMo", 1024, 16, 102400);
b.pop();
SPEC = b.build();
}
private GardeSpec() { }
public static void onConfig(ModConfigEvent event) {
if (event.getConfig().getSpec() == SPEC) {
acCache = null;
appliquer(Garde.config());
Garde.surConfigChargee();
}
}
/** Recopie les valeurs du fichier dans la configuration du moteur (si le fichier est chargé). */
public static void appliquer(GardeConfig c) {
if (!SPEC.isLoaded()) return;
for (Map.Entry<Controle, ModConfigSpec.EnumValue<Mode>> e : MODES.entrySet()) {
c.mode(e.getKey(), e.getValue().get());
}
c.vlDecroissanceParSeconde = VL_DECROISSANCE.get();
c.seuilAlerte = SEUIL_ALERTE.get();
c.seuilSetback = Math.max(SEUIL_SETBACK.get(), c.seuilAlerte);
c.seuilExpulsion = Math.max(SEUIL_EXPULSION.get(), c.seuilSetback);
c.sanctionMax = SANCTION_MAX.get();
c.angleMaxDegres = ANGLE_MAX.get();
c.ciblesMax = CIBLES_MAX.get();
c.fenetreCiblesMs = FENETRE_CIBLES_MS.get();
c.cpsMax = CPS_MAX.get();
c.ecartTypeMinMs = ECART_TYPE_MIN.get();
c.intervalleMoyenMaxMs = INTERVALLE_MOYEN_MAX.get();
c.paquetsParSecondeMax = PAQUETS_PAR_SECONDE.get();
c.timerSecondesSoutenues = TIMER_SECONDES.get();
c.excesVitesseBlocs = EXCES_VITESSE.get();
c.porteeToleranceBlocs = PORTEE_TOLERANCE.get();
c.hitboxMargeBlocs = HITBOX_MARGE.get();
c.ticksLatenceCible = TICKS_LATENCE_CIBLE.get();
c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get();
c.pingLatenceMaxMs = PING_LATENCE_MAX.get();
c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get();
c.ticksAffichageCible = TICKS_AFFICHAGE.get();
c.seriePingMaxMs = SERIE_PING_MAX.get();
c.serieManqueBlocs = SERIE_MANQUE.get();
c.seriePorteeMargeBlocs = SERIE_PORTEE.get();
c.serieCoups = SERIE_COUPS.get();
c.serieHorsMin = Math.min(SERIE_HORS_MIN.get(), c.serieCoups);
c.serieFenetreMs = SERIE_FENETRE_MS.get();
c.seriePoints = SERIE_POINTS.get();
c.graceTeleportTicks = GRACE_TELEPORT.get();
c.graceReculTicks = GRACE_RECUL.get();
c.graceGelTicks = GRACE_GEL.get();
c.tpsLag = TPS_LAG.get();
c.pingLagMs = PING_LAG.get();
c.facteurLag = FACTEUR_LAG.get();
}
// --- Réglages propres à l'adaptateur ---
public static String prefixesContraption() {
return SPEC.isLoaded() ? PREFIXES_CONTRAPTION.get() : PREFIXES_CONTRAPTION.getDefault();
}
public static int distanceContraption() {
return SPEC.isLoaded() ? DISTANCE_CONTRAPTION.get() : DISTANCE_CONTRAPTION.getDefault();
}
public static java.util.Set<String> blocsCourantAir() {
return ensemble(SPEC.isLoaded() ? BLOCS_COURANT_AIR.get() : BLOCS_COURANT_AIR.getDefault());
}
public static int distanceCourantAir() {
return SPEC.isLoaded() ? DISTANCE_COURANT_AIR.get() : DISTANCE_COURANT_AIR.getDefault();
}
public static java.util.Set<String> blocsEntrainement() {
return ensemble(SPEC.isLoaded() ? BLOCS_ENTRAINEMENT.get() : BLOCS_ENTRAINEMENT.getDefault());
}
private static String ensembleSource;
private static java.util.Set<String> ensembleCache = java.util.Set.of();
private static String ensembleSource2;
private static java.util.Set<String> ensembleCache2 = java.util.Set.of();
/** Liste « a, b, c » en ensemble ; deux dernières listes gardées en cache (appelé à chaque paquet). */
private static synchronized java.util.Set<String> ensemble(String liste) {
if (liste == null) return java.util.Set.of();
if (liste.equals(ensembleSource)) return ensembleCache;
if (liste.equals(ensembleSource2)) return ensembleCache2;
java.util.Set<String> e = new java.util.HashSet<>(com.gastinelgarde.core.DetectionContraption.motifs(liste));
ensembleSource2 = ensembleSource;
ensembleCache2 = ensembleCache;
ensembleSource = liste;
ensembleCache = java.util.Set.copyOf(e);
return ensembleCache;
}
/** Réglages anti-crash courants (valeurs par défaut si le fichier n'est pas chargé). */
public static com.gastinelgarde.core.AntiCrashEntites.Reglages antiCrash() {
com.gastinelgarde.core.AntiCrashEntites.Reglages r = acCache;
if (r != null) return r; // appelé pour chaque entité à chaque tick : relu seulement au (re)chargement
r = lireAntiCrash();
if (SPEC.isLoaded()) acCache = r;
return r;
}
private static volatile com.gastinelgarde.core.AntiCrashEntites.Reglages acCache;
private static com.gastinelgarde.core.AntiCrashEntites.Reglages lireAntiCrash() {
com.gastinelgarde.core.AntiCrashEntites.Reglages r = new com.gastinelgarde.core.AntiCrashEntites.Reglages();
boolean l = SPEC.isLoaded();
r.actif = l ? AC_ACTIF.get() : AC_ACTIF.getDefault();
r.vitesseMax = l ? AC_VITESSE_MAX.get() : AC_VITESSE_MAX.getDefault();
r.facteurSuppression = l ? AC_FACTEUR_SUPPRESSION.get() : AC_FACTEUR_SUPPRESSION.getDefault();
r.margeBordure = l ? AC_MARGE_BORDURE.get() : AC_MARGE_BORDURE.getDefault();
r.vitesseMaxMinecart = l ? AC_VITESSE_MINECART.get() : AC_VITESSE_MINECART.getDefault();
r.empilementMax = l ? AC_EMPILEMENT_MAX.get() : AC_EMPILEMENT_MAX.getDefault();
return r;
}
public static boolean antiCrashAlertesOps() {
return SPEC.isLoaded() ? AC_ALERTES_OPS.get() : AC_ALERTES_OPS.getDefault();
}
public static boolean tracesActives() {
return SPEC.isLoaded() ? TRACES_ACTIVES.get() : TRACES_ACTIVES.getDefault();
}
public static int tracesJours() {
return SPEC.isLoaded() ? TRACES_JOURS.get() : TRACES_JOURS.getDefault();
}
public static long tracesTailleOctets() {
int mo = SPEC.isLoaded() ? TRACES_TAILLE_MO.get() : TRACES_TAILLE_MO.getDefault();
return mo * 1024L * 1024L;
}
/** Modifie un mode dans le fichier de configuration (conservé au prochain démarrage). */
public static void definirMode(Controle c, Mode m) {
ModConfigSpec.EnumValue<Mode> v = MODES.get(c);
if (v != null && SPEC.isLoaded()) {
v.set(m);
SPEC.save();
}
}
}