Fichiers
gastinel-garde/src/main/java/com/gastinelgarde/GardeSpec.java
T
gastineltetClaude Sonnet 5.5 adc326a897 P1.13 : diagnostic « Mismatch in destroy block pos »
- core.ActionsBloc : START / ABORT de casse de bloc (LeftClickBlock, ecoute
  en LOWEST, meme annule). Un ABORT sans START accepte correspondant donne
  une ligne DIAGNOSTIC (au plus une toutes les 10 s par joueur), avec le
  dernier START et s'il a ete annule par un mod.
- D'apres ServerPlayerGameMode (sources NeoForge 21.1.234), destroyPos vaut
  (0,0,0) tant qu'aucun START n'a ete accepte : un START annule par une
  protection de zone puis un ABORT suffit a produire le message.
- Reglage [diagnostic] : actionsBlocIncoherentes (true). Jamais de sanction.
- Tests : ActionsBlocP1Test.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-10-24 00:36:45 +02:00

538 lignes
35 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.BooleanValue JOURNAL_TOUJOURS, SETBACK_SOL, DIAG_ACTIONS;
private static final ModConfigSpec.IntValue GRACE_CONNEXION, GRACE_APRES_EXPULSION;
private static final ModConfigSpec.DoubleValue STEP_HAUTEUR, STEP_MARGE, CRIT_MICRO;
private static final ModConfigSpec.IntValue CRIT_SERIE, ANTI_FAIM_TICKS, ELY_DEPLOIEMENTS;
private static final ModConfigSpec.IntValue JOURNAL_LIMITE;
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.IntValue SERIE_PING_MARGE;
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX, TIMER_DETTE_MAX;
private static final ModConfigSpec.IntValue ELY_MONTEE, ELY_STATIONNAIRE, VEL_FENETRE, VEL_SERIE, TOTEM_DELAI, TOTEM_PING;
private static final ModConfigSpec.DoubleValue VEL_RAPPORT, VEL_FORCE, VEL_POINTS, TOTEM_SEUIL_SB, TOTEM_SEUIL_EXP, VEL_SEUIL_SB, VEL_SEUIL_EXP;
private static final ModConfigSpec.BooleanValue SUSP_ACTIVE;
private static final ModConfigSpec.DoubleValue SUSP_SURVEILLER, SUSP_SUSPECT, SUSP_FORT, SUSP_DEMI_VIE,
SUSP_PLAFOND_FIABLE, SUSP_PLAFOND_MOYEN, SUSP_PLAFOND_FAIBLE, SUSP_DIVERSITE_FENETRE;
private static final ModConfigSpec.IntValue SUSP_DIVERSITE, SUSP_JOURS, VOL_FLOTTEMENT;
private static final ModConfigSpec.BooleanValue VOL_FENETRE_GLISSANTE;
private static final ModConfigSpec.BooleanValue VITESSE_MOYENNE;
private static final ModConfigSpec.BooleanValue ELYTRES_STRICTE;
private static final ModConfigSpec.IntValue ELYTRES_AIR_MIN;
private static final ModConfigSpec.BooleanValue COMBAT_VEHICULE;
private static final ModConfigSpec.BooleanValue AC_EMPILEMENT_MOUVEMENT;
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.comment("0.5 : journal logs/gastinelgarde.log.").push("journal");
JOURNAL_TOUJOURS = b.comment("Le verdict qui déclenche un SETBACK ou une EXPULSION est toujours écrit, malgré la limite ci-dessous.")
.define("toujoursEcrireSanctions", true);
JOURNAL_LIMITE = b.comment("Lignes au plus par seconde et par contrôle (évite une ligne par tick pendant une chute).")
.defineInRange("limiteLignesParSeconde", 1, 1, 20);
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);
CRIT_MICRO = b.comment("0.5 (P1.10) criticals : critique suspect si, depuis le dernier « au sol » du client, le joueur n'est ni monté",
"ni descendu de plus de cette valeur (blocs). Vrai saut : ~1,25 ; micro-saut de cheat : 0,0625.")
.defineInRange("criticalsMicroSautMax", 0.1, 0.01, 1.0);
CRIT_SERIE = b.comment("Criticals : critiques suspects, parmi les 10 derniers en 60 s, avant qu'un critique suspect compte.")
.defineInRange("criticalsSerieMin", 3, 1, 10);
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) pris en compte au plus dans la fenêtre (au-delà, le coup est mesuré avec cette fenêtre).")
.defineInRange("seriePingMaxMs", 500, 100, 500);
SERIE_PING_MARGE = b.comment("Fenêtre selon le ping le plus bas des 2 dernières minutes + cette marge (ms), pas le ping du moment.")
.defineInRange("seriePingMargeMs", 50, 0, 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);
TIMER_SOLDE_MAX = b.comment("C15 : solde de paquets (reçus - ticks écoulés) au-delà duquel le timer compte (timer 1,05-1,10).",
"0 = désactivé. 0.5 : 20 par défaut (un fichier existant garde sa valeur).")
.defineInRange("timerSoldeMax", 20, 0, 1000);
TIMER_DETTE_MAX = b.comment("0.5 : crédit au plus (paquets en retard pendant un lag) remboursable par la rafale de rattrapage.")
.defineInRange("timerDetteMax", 40, 0, 1000);
b.pop();
b.comment("Score de suspicion de 0 à 100 par joueur (0.4.0). INFORMATION POUR LES HUMAINS : aucune sanction n'en découle.",
"Chaque contrôle (même en OBSERVE) contribue (VL / seuilExpulsion, au plus 1) x son plafond selon sa fiabilité ;",
"le pic décroît avec une demi-vie. Journal dès seuilSurveiller ; message aux ops dès seuilSuspect ;",
"dès seuilFort, proposition de sanction suspect_2 à valider dans le Portail (jamais appliquée par le mod).")
.push("suspicion");
SUSP_ACTIVE = b.define("actif", true);
SUSP_SURVEILLER = b.defineInRange("seuilSurveiller", 25.0, 1.0, 100.0);
SUSP_SUSPECT = b.defineInRange("seuilSuspect", 50.0, 1.0, 100.0);
SUSP_FORT = b.defineInRange("seuilFort", 75.0, 1.0, 100.0);
SUSP_DEMI_VIE = b.comment("Demi-vie du score, en minutes de jeu (le suivi est libéré à la déconnexion).")
.defineInRange("demiVieMinutes", 10.0, 0.5, 1440.0);
SUSP_PLAFOND_FIABLE = b.comment("Plafond de contribution : vol, vitesse, no-fall, portee, hitbox, regularite.")
.defineInRange("plafondFiable", 50.0, 0.0, 100.0);
SUSP_PLAFOND_MOYEN = b.comment("Plafond : coups-hors-boite, killaura-angle, killaura-cibles, cadence.")
.defineInRange("plafondMoyen", 30.0, 0.0, 100.0);
SUSP_PLAFOND_FAIBLE = b.comment("Plafond : timer, rotation, attaque-impossible, vehicule-vitesse, vehicule-vol (faux positifs).")
.defineInRange("plafondFaible", 15.0, 0.0, 100.0);
SUSP_DIVERSITE = b.comment("Ce nombre de contrôles distincts au palier SETBACK dans la fenêtre = suspect fort ; 0 = coupé.")
.defineInRange("diversiteControles", 3, 0, 20);
SUSP_DIVERSITE_FENETRE = b.defineInRange("diversiteFenetreMinutes", 10.0, 0.5, 1440.0);
SUSP_JOURS = b.comment("Historique des incidents par UUID (gastinelgarde-suspicion/incidents.csv), en jours.")
.defineInRange("historiqueJours", 7, 1, 365);
b.pop();
b.comment("0.4.0 : plané en élytres (Elytra Hack), recul absent après un coup subi (Anti Knockback / Anti Push),",
"totem remis en main sans délai humain (Auto Totem). Contrôles 'elytres', 'velocite' et 'auto-totem' : OBSERVE par défaut.")
.push("nouveauxControles");
ELY_MONTEE = b.comment("Ticks de montée sans perte de vitesse en plané avant infraction ; 0 = coupé.")
.defineInRange("elytresMonteeTicks", 20, 0, 600);
ELY_STATIONNAIRE = b.comment("Ticks de plané presque immobile sans chute avant infraction ; 0 = coupé.")
.defineInRange("elytresStationnaireTicks", 20, 0, 600);
ELY_DEPLOIEMENTS = b.comment("0.5 (P1.6) : déploiements d'élytres au plus par seconde ; au-delà, ElytraFly « packet » (un START_FALL_FLYING",
"pendant le plané l'arrête, le suivant le relance). 0 = coupé.")
.defineInRange("elytresDeploiementsMax", 5, 0, 20);
VEL_FENETRE = b.defineInRange("velociteFenetreTicks", 6, 2, 20);
VEL_RAPPORT = b.comment("Recul absent si le déplacement dans le sens du recul est sous cette part du recul vanilla.")
.defineInRange("velociteRapportMin", 0.15, 0.0, 1.0);
VEL_SERIE = b.comment("Reculs absents (sur les 6 derniers en 2 minutes) avant infraction.")
.defineInRange("velociteSerieMin", 3, 1, 6);
VEL_FORCE = b.defineInRange("velociteForceMin", 0.15, 0.0, 5.0);
VEL_POINTS = b.comment("0.4.1 : points ajoutes par recul absent (en serie). 4 : 6 reculs absents espaces de 3 s depassent le SETBACK (10).")
.defineInRange("velocitePoints", 4.0, 0.0, 20.0);
TOTEM_SEUIL_SB = b.comment("0.4.2 : seuils propres (0 = seuil global de [sanctions]). Auto-totem : le palier SETBACK reste une alerte.")
.defineInRange("autoTotemSeuilSetback", 0.0, 0.0, 1000.0);
TOTEM_SEUIL_EXP = b.comment("Auto-totem : expulsion en ENFORCE (9 = trois detections rapprochees a +3).")
.defineInRange("autoTotemSeuilExpulsion", 9.0, 0.0, 1000.0);
VEL_SEUIL_SB = b.comment("Velocite : retour en arriere (setback) en ENFORCE.")
.defineInRange("velociteSeuilSetback", 8.0, 0.0, 1000.0);
VEL_SEUIL_EXP = b.comment("Velocite : expulsion en ENFORCE.")
.defineInRange("velociteSeuilExpulsion", 16.0, 0.0, 1000.0);
TOTEM_DELAI = b.comment("Réaction humaine minimale (ms) entre l'éclatement et le totem remis en main, ping en plus.")
.defineInRange("totemDelaiMinMs", 150, 0, 2000);
TOTEM_PING = b.defineInRange("totemPingMaxMs", 200, 0, 1000);
b.pop();
b.push("mouvement");
VOL_FLOTTEMENT = b.comment("Vol : ticks consécutifs en l'air sans chute avant infraction (vanilla : 80, 'kicked for floating too long').",
"Remplace ce contrôle vanilla si allow-flight=true. 0 = coupé.")
.defineInRange("volFlottementTicks", 80, 0, 1200);
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);
VOL_FENETRE_GLISSANTE = b.comment("C10 : vol, ticks anormaux sur une fenêtre glissante et sauts en l'air répétés.",
"Désactivé par défaut : à essayer en OBSERVE (vol est en ENFORCE en production).")
.define("volFenetreGlissante", false);
VITESSE_MOYENNE = b.comment("C15 : vitesse moyenne sur 40 paquets comparée à la moyenne vanilla (course, sprint-saut).",
"Désactivé par défaut : à essayer en OBSERVE (fausse alerte possible sous un plafond bas, C16).")
.define("vitesseMoyenne", false);
ELYTRES_STRICTE = b.comment("C7 : plané déclenché sans ticks en l'air (sol serveur) = pas d'exemption de mouvement ;",
"portée et hitbox mesurées pendant le plané. Désactivé par défaut : à essayer en OBSERVE.")
.define("elytresExemptionStricte", false);
ELYTRES_AIR_MIN = b.comment("C7 : ticks en l'air (sol serveur) exigés avant le déploiement des élytres.")
.defineInRange("elytresAirMinTicks", 2, 1, 20);
COMBAT_VEHICULE = b.comment("C8 : le combat d'un passager de véhicule (bateau, cheval, minecart) est mesuré comme à pied.",
"Désactivé par défaut : à essayer en OBSERVE (portée, hitbox, killaura).")
.define("combatMesureEnVehicule", false);
STEP_HAUTEUR = b.comment("0.5 (P1.9) step : hauteur de marche au moins permise en un tick (vanilla : attribut step_height 0,6).",
"L'attribut réel du joueur et sa puissance de saut (0,42 + Saut amélioré) relèvent le seuil.")
.defineInRange("stepHauteurMax", 0.6, 0.5, 10.0);
STEP_MARGE = b.comment("Step : marge (blocs) au-dessus de la hauteur permise.")
.defineInRange("stepMargeBlocs", 0.1, 0.0, 2.0);
ANTI_FAIM_TICKS = b.comment("0.5 (P1.8) anti-faim : paquets consécutifs de course au sol (vu par le serveur, sans déplacement vertical)",
"déclarée « en l'air » par le client avant infraction. Vanilla ne compte la faim de course qu'au sol.")
.defineInRange("antiFaimTicks", 20, 5, 1200);
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.")
.define("actionsBlocIncoherentes", true);
b.pop();
b.comment("0.5 : grâces à la connexion (reconnexion en l'air, expulsion récente).").push("graces");
GRACE_CONNEXION = b.comment("Ticks sans contrôle de mouvement ni timer après la connexion (la téléportation de connexion en donne déjà graceTeleportTicks).")
.defineInRange("graceConnexionTicks", 100, 0, 1200);
GRACE_APRES_EXPULSION = b.comment("Idem si le joueur a été expulsé il y a moins de 10 minutes.")
.defineInRange("graceApresExpulsionTicks", 200, 0, 2400);
SETBACK_SOL = b.comment("Sans position de retour valide (reconnexion en l'air), le SETBACK ramène au sol juste sous le joueur.",
"Jamais de déplacement horizontal. false = ancien comportement (setback impossible, seulement journalisé).")
.define("setbackSolSiPasDePosition", true);
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_EMPILEMENT_MOUVEMENT = b.comment("C18 : ne casser que les minecarts empilés en mouvement ou sans contenu ; un stockage",
"immobile de minecarts à coffre / à trémie n'est plus cassé (poussée coupée, journal seulement). Défaut false.")
.define("empilementSeulementEnMouvement", false);
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.journalToujoursSanctions = JOURNAL_TOUJOURS.get();
c.journalLignesParSeconde = JOURNAL_LIMITE.get();
c.diagnosticActionsBloc = DIAG_ACTIONS.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.seriePingMargeMs = SERIE_PING_MARGE.get();
c.timerSoldeMax = TIMER_SOLDE_MAX.get();
c.timerDetteMax = TIMER_DETTE_MAX.get();
c.suspicionActive = SUSP_ACTIVE.get();
c.suspicionSeuilSurveiller = SUSP_SURVEILLER.get();
c.suspicionSeuilSuspect = Math.max(SUSP_SUSPECT.get(), c.suspicionSeuilSurveiller);
c.suspicionSeuilFort = Math.max(SUSP_FORT.get(), c.suspicionSeuilSuspect);
c.suspicionDemiVieMinutes = SUSP_DEMI_VIE.get();
c.suspicionPlafondFiable = SUSP_PLAFOND_FIABLE.get();
c.suspicionPlafondMoyen = SUSP_PLAFOND_MOYEN.get();
c.suspicionPlafondFaible = SUSP_PLAFOND_FAIBLE.get();
c.suspicionDiversiteControles = SUSP_DIVERSITE.get();
c.suspicionDiversiteFenetreMinutes = SUSP_DIVERSITE_FENETRE.get();
c.suspicionHistoriqueJours = SUSP_JOURS.get();
c.volFlottementTicks = VOL_FLOTTEMENT.get();
c.elytresMonteeTicks = ELY_MONTEE.get();
c.elytresStationnaireTicks = ELY_STATIONNAIRE.get();
c.elytresDeploiementsMax = ELY_DEPLOIEMENTS.get();
c.velociteFenetreTicks = VEL_FENETRE.get();
c.velociteRapportMin = VEL_RAPPORT.get();
c.velociteSerieMin = VEL_SERIE.get();
c.velociteForceMin = VEL_FORCE.get();
c.velocitePoints = VEL_POINTS.get();
c.autoTotemSeuilSetback = TOTEM_SEUIL_SB.get();
c.autoTotemSeuilExpulsion = TOTEM_SEUIL_EXP.get();
c.velociteSeuilSetback = VEL_SEUIL_SB.get();
c.velociteSeuilExpulsion = VEL_SEUIL_EXP.get();
c.totemDelaiMinMs = TOTEM_DELAI.get();
c.totemPingMaxMs = TOTEM_PING.get();
c.volFenetreGlissante = VOL_FENETRE_GLISSANTE.get();
c.vitesseMoyenne = VITESSE_MOYENNE.get();
c.elytresExemptionStricte = ELYTRES_STRICTE.get();
c.elytresAirMinTicks = ELYTRES_AIR_MIN.get();
c.combatMesureEnVehicule = COMBAT_VEHICULE.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.graceConnexionTicks = GRACE_CONNEXION.get();
c.stepHauteurMax = STEP_HAUTEUR.get();
c.stepMargeBlocs = STEP_MARGE.get();
c.criticalsMicroSautMax = CRIT_MICRO.get();
c.criticalsSerieMin = CRIT_SERIE.get();
c.antiFaimTicks = ANTI_FAIM_TICKS.get();
c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
c.setbackSolSiPasDePosition = SETBACK_SOL.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();
r.empilementSeulementEnMouvement = l ? AC_EMPILEMENT_MOUVEMENT.get() : AC_EMPILEMENT_MOUVEMENT.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();
}
}
}