- 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>
538 lignes
35 KiB
Java
538 lignes
35 KiB
Java
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();
|
||
}
|
||
}
|
||
}
|