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>
354 lignes
21 KiB
Java
354 lignes
21 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.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();
|
||
}
|
||
}
|
||
}
|