From e87b8374ef47631084325d17cce27ee58d0cfaa5 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Fri, 23 Oct 2026 19:38:40 +0200 Subject: [PATCH] 0.4.2 : vraies sanctions pour auto-totem et velocite, seuils propres - bride ALERTE retiree en ENFORCE ; auto-totem : palier SETBACK ramene a ALERTE, expulsion appliquee - velocite : SETBACK = retour en arriere (setback mouvement existant), expulsion - seuils optionnels dans [nouveauxControles] : autoTotemSeuilSetback (0 = global), autoTotemSeuilExpulsion = 9, velociteSeuilSetback = 8, velociteSeuilExpulsion = 16 (0 = seuil global de [sanctions]) - version 0.4.2 Co-Authored-By: Claude Opus 5.5 --- gradle.properties | 2 +- src/main/java/com/gastinelgarde/Garde.java | 6 +- .../java/com/gastinelgarde/GardeSpec.java | 14 +- .../com/gastinelgarde/core/GardeConfig.java | 5 + .../java/com/gastinelgarde/core/Moteur.java | 6 +- .../java/com/gastinelgarde/core/Paliers.java | 27 +++- .../resources/META-INF/neoforge.mods.toml | 2 +- .../java/com/gastinelgarde/CablageTest.java | 13 ++ .../core/NouveauxControlesTest.java | 8 +- .../gastinelgarde/core/Sanctions042Test.java | 128 ++++++++++++++++++ 10 files changed, 197 insertions(+), 14 deletions(-) create mode 100644 src/test/java/com/gastinelgarde/core/Sanctions042Test.java diff --git a/gradle.properties b/gradle.properties index 9dd0c5c..e22caf3 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,7 +1,7 @@ org.gradle.jvmargs=-Xmx2G org.gradle.parallel=true -mod_version=0.4.1 +mod_version=0.4.2 mod_group_id=com.gastinelgarde mod_id=gastinelgarde diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 86bd808..35c5bc7 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -699,11 +699,13 @@ public final class Garde { List v = MOTEUR.mesureRecul(p.getUUID(), maintenant, etatSup, p.getX() - m.mouvementX, p.getZ() - m.mouvementZ, milieuSpecial(p, m, tick), (ux, uz) -> !p.level().noCollision(p, p.getBoundingBox().move(ux * 0.3, 0, uz * 0.3))); - traiter(p, v); // information seulement : jamais de setback ni d'expulsion pour la vélocité + Sanction sv = traiter(p, v); // 0.4.2 : setback (retour en arrière) ou expulsion en ENFORCE + if (Cablage.sanctionDeMouvement(sv)) appliquerSanctionMouvement(p, sv, v); } boolean totem = p.getMainHandItem().is(Items.TOTEM_OF_UNDYING) || p.getOffhandItem().is(Items.TOTEM_OF_UNDYING); List vt = MOTEUR.totemEnMain(p.getUUID(), maintenant, etatSup, totem); - traiter(p, vt); // information seulement : jamais de setback pour un totem + Sanction st = traiter(p, vt); // 0.4.2 : expulsion en ENFORCE (le palier SETBACK reste une alerte) + if (st == Sanction.EXPULSION) appliquerSanctionMouvement(p, st, vt); } m.mouvementTick = tick; m.mouvementX = p.getX(); diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index 56efc4d..994490c 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -52,7 +52,7 @@ public final class GardeSpec { private static final ModConfigSpec.IntValue SERIE_PING_MARGE; private static final ModConfigSpec.IntValue TIMER_SOLDE_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; + 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; @@ -200,6 +200,14 @@ public final class GardeSpec { 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); @@ -352,6 +360,10 @@ public final class GardeSpec { 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(); diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index ab0a59f..42ffdea 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -61,6 +61,11 @@ public final class GardeConfig { public double velociteForceMin = 0.15; /** 0.4.1 : points par recul absent compte (en serie). 2 en dur en 0.4.0 : la decroissance (0,5/s) plafonnait le VL vers 5. */ public double velocitePoints = 4.0; + /** 0.4.2 : seuils propres a un controle ; valeur <= 0 = seuil global de [sanctions]. */ + public double autoTotemSeuilSetback = 0; + public double autoTotemSeuilExpulsion = 9; + public double velociteSeuilSetback = 8; + public double velociteSeuilExpulsion = 16; /** Réaction humaine minimale (ms) entre l'éclatement d'un totem et un totem remis en main, hors ping. */ public int totemDelaiMinMs = 150; /** Ping (ms) au plus ajouté à ce délai (le ping est falsifiable). */ diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index 3cdab9c..005a73f 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -595,7 +595,7 @@ public final class Moteur { if (points <= 0) return; Mode mode = cfg.mode(c); double vl = s.vl.ajouter(c, points, nowMs); - Sanction palier = Paliers.palier(vl, cfg); + Sanction palier = Paliers.palier(vl, cfg, c); // 0.4.2 : seuils propres a auto-totem et velocite // C5 (16/10) : après un setback, le VL repart de zéro ; l'expulsion vient après plusieurs setbacks récents. if (palier == Sanction.SETBACK && cfg.setbacksAvantExpulsion > 0 && s.setbacksRecents(nowMs, cfg.fenetreSetbacksMs) >= cfg.setbacksAvantExpulsion) { @@ -604,7 +604,9 @@ public final class Moteur { Sanction applicable = Paliers.applicable(palier, mode); // 0.4.0 : vélocité et auto-totem sont bridés dans le code (un tiers peut provoquer de faux positifs) : jamais de // setback ni d'expulsion, même si la configuration les passe en ENFORCE. Ils nourrissent le score de suspicion. - if (c == Controle.VELOCITE || c == Controle.AUTO_TOTEM) applicable = Sanction.min(applicable, Sanction.ALERTE); + // 0.4.2 (decision de Theo) : vraies sanctions en ENFORCE. Auto-totem n'a pas de retour en arriere qui ait un + // sens : son palier SETBACK reste une ALERTE, l'expulsion s'applique. Velocite : SETBACK = retour en arriere. + if (c == Controle.AUTO_TOTEM && applicable == Sanction.SETBACK) applicable = Sanction.ALERTE; s.suspicion.noter(c, vl, palier.ordinal() >= Sanction.SETBACK.ordinal(), horloge.getAsLong()); boolean notifier = applicable.ordinal() >= Sanction.ALERTE.ordinal() && s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS); diff --git a/src/main/java/com/gastinelgarde/core/Paliers.java b/src/main/java/com/gastinelgarde/core/Paliers.java index c84a2bb..dea2264 100644 --- a/src/main/java/com/gastinelgarde/core/Paliers.java +++ b/src/main/java/com/gastinelgarde/core/Paliers.java @@ -7,11 +7,32 @@ public final class Paliers { /** Sanction que mériterait ce nombre de points, plafonnée par {@code sanctionMax}. */ public static Sanction palier(double vl, GardeConfig cfg) { + return palier(vl, cfg.seuilAlerte, cfg.seuilSetback, cfg.seuilExpulsion, cfg); + } + + /** 0.4.2 : palier avec les seuils propres au contrôle (auto-totem, vélocité) quand ils sont définis (> 0). */ + public static Sanction palier(double vl, GardeConfig cfg, Controle c) { + double setback = cfg.seuilSetback; + double expulsion = cfg.seuilExpulsion; + if (c == Controle.AUTO_TOTEM) { + if (cfg.autoTotemSeuilSetback > 0) setback = cfg.autoTotemSeuilSetback; + if (cfg.autoTotemSeuilExpulsion > 0) expulsion = cfg.autoTotemSeuilExpulsion; + } else if (c == Controle.VELOCITE) { + if (cfg.velociteSeuilSetback > 0) setback = cfg.velociteSeuilSetback; + if (cfg.velociteSeuilExpulsion > 0) expulsion = cfg.velociteSeuilExpulsion; + } + setback = Math.min(setback, expulsion); + double alerte = Math.min(cfg.seuilAlerte, setback); + return palier(vl, alerte, setback, expulsion, cfg); + } + + private static Sanction palier(double vl, double seuilAlerte, double seuilSetback, double seuilExpulsion, + GardeConfig cfg) { Sanction s; if (vl <= 0) s = Sanction.AUCUNE; - else if (vl < cfg.seuilAlerte) s = Sanction.JOURNAL; - else if (vl < cfg.seuilSetback) s = Sanction.ALERTE; - else if (vl < cfg.seuilExpulsion) s = Sanction.SETBACK; + else if (vl < seuilAlerte) s = Sanction.JOURNAL; + else if (vl < seuilSetback) s = Sanction.ALERTE; + else if (vl < seuilExpulsion) s = Sanction.SETBACK; else s = Sanction.EXPULSION; return Sanction.min(s, cfg.sanctionMax); } diff --git a/src/main/resources/META-INF/neoforge.mods.toml b/src/main/resources/META-INF/neoforge.mods.toml index 21d5cab..61b6c8f 100644 --- a/src/main/resources/META-INF/neoforge.mods.toml +++ b/src/main/resources/META-INF/neoforge.mods.toml @@ -4,7 +4,7 @@ license="MIT" [[mods]] modId="gastinelgarde" -version="0.4.1" +version="0.4.2" displayName="GastinelGarde" authors="Théo Gastinel" description='''Anti-triche maison : combat, cadence, rotation, timer (phase 1), no-fall, vitesse, vol et véhicules (phase 2), points d'infraction avec décroissance, setback puis expulsion, jamais de bannissement automatique. Mod côté serveur uniquement.''' diff --git a/src/test/java/com/gastinelgarde/CablageTest.java b/src/test/java/com/gastinelgarde/CablageTest.java index e9b9800..dcb113b 100644 --- a/src/test/java/com/gastinelgarde/CablageTest.java +++ b/src/test/java/com/gastinelgarde/CablageTest.java @@ -120,6 +120,19 @@ class CablageTest { // --- Setback (C2, C3) --- + @Test + void v042_setbackVelociteRameneLaPositionEtExpulsionAutoTotemDeconnecte() { + Moteur moteur = new Moteur(new GardeConfig()); + FauxJoueur p = new FauxJoueur(); + moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE); + Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VELOCITE, Sanction.SETBACK))); + assertEquals(List.of("annonce SETBACK", "teleport 10.5 64.0 -3.5 90 10", "journal Tricheur SETBACK (velocite)"), + p.actions); + Cablage.appliquerSanction(moteur, p, Sanction.EXPULSION, List.of(verdict(Controle.AUTO_TOTEM, Sanction.EXPULSION))); + assertEquals(1, p.compte("deconnexion")); + assertTrue(moteur.estExpulse(ID)); + } + @Test void C2_setbackVersLaPositionAuSolPuisRemiseAZeroDuVol() { Moteur moteur = new Moteur(new GardeConfig()); diff --git a/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java b/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java index e20f781..2d84966 100644 --- a/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java +++ b/src/test/java/com/gastinelgarde/core/NouveauxControlesTest.java @@ -316,9 +316,9 @@ class NouveauxControlesTest { } @Test - void velociteEtAutoTotemJamaisDeSanctionMemeEnEnforce() { - cfg.mode(Controle.VELOCITE, Mode.ENFORCE); - cfg.mode(Controle.AUTO_TOTEM, Mode.ENFORCE); + void velociteEtAutoTotemJamaisDeSanctionEnObserve() { // 0.4.2 : en ENFORCE, voir Sanctions042Test + cfg.mode(Controle.VELOCITE, Mode.OBSERVE); + cfg.mode(Controle.AUTO_TOTEM, Mode.OBSERVE); boolean vu = false; for (int k = 0; k < 40; k++) { now += 50; @@ -553,7 +553,7 @@ class NouveauxControlesTest { for (Verdict v : moteur.totemEnMain(j, now, EtatJoueur.normal(), true)) { vus++; assertEquals(Mode.ENFORCE, v.mode()); - assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal(), "jamais setback ni expulsion"); + assertTrue(v.applicable() != Sanction.SETBACK, "0.4.2 : auto-totem n'a pas de setback (expulsion possible)"); } } assertEquals(10, vus, "les detections continuent en ENFORCE"); diff --git a/src/test/java/com/gastinelgarde/core/Sanctions042Test.java b/src/test/java/com/gastinelgarde/core/Sanctions042Test.java new file mode 100644 index 0000000..9a9a515 --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/Sanctions042Test.java @@ -0,0 +1,128 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.UUID; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +/** 0.4.2 : vraies sanctions pour auto-totem et velocite, seuils propres a ces controles. */ +class Sanctions042Test { + + private GardeConfig cfg; + private Moteur moteur; + private final UUID j = UUID.randomUUID(); + private long now; + + @BeforeEach + void init() { + cfg = new GardeConfig(); + moteur = new Moteur(cfg); + now = 1_000_000; + } + + @Test + void seuilsParDefaut() { + assertEquals(9, cfg.autoTotemSeuilExpulsion, 1e-9); + assertEquals(8, cfg.velociteSeuilSetback, 1e-9); + assertEquals(16, cfg.velociteSeuilExpulsion, 1e-9); + } + + @Test + void paliersVelocite() { + assertEquals(Sanction.ALERTE, Paliers.palier(7.9, cfg, Controle.VELOCITE)); + assertEquals(Sanction.SETBACK, Paliers.palier(8, cfg, Controle.VELOCITE)); + assertEquals(Sanction.SETBACK, Paliers.palier(15.9, cfg, Controle.VELOCITE)); + assertEquals(Sanction.EXPULSION, Paliers.palier(16, cfg, Controle.VELOCITE)); + } + + @Test + void paliersAutoTotem() { + assertEquals(Sanction.EXPULSION, Paliers.palier(9, cfg, Controle.AUTO_TOTEM)); + assertTrue(Paliers.palier(8.9, cfg, Controle.AUTO_TOTEM).ordinal() < Sanction.EXPULSION.ordinal()); + } + + @Test + void seuilsAZeroRetombentSurLesSeuilsGlobaux() { + cfg.velociteSeuilSetback = 0; + cfg.velociteSeuilExpulsion = 0; + cfg.autoTotemSeuilExpulsion = 0; + for (double vl : new double[] {3, 9, 12, 15, 25}) { + assertEquals(Paliers.palier(vl, cfg), Paliers.palier(vl, cfg, Controle.VELOCITE)); + assertEquals(Paliers.palier(vl, cfg), Paliers.palier(vl, cfg, Controle.AUTO_TOTEM)); + } + cfg.velociteSeuilSetback = 8; + assertEquals(Paliers.palier(9, cfg), Paliers.palier(9, cfg, Controle.VITESSE), "autres controles inchanges"); + } + + @Test + void sanctionMaxResteRespecte() { + cfg.sanctionMax = Sanction.SETBACK; + assertEquals(Sanction.SETBACK, Paliers.palier(50, cfg, Controle.VELOCITE)); + } + + private List totem() { + moteur.totemEclate(j, now, false); + now += 50; + return moteur.totemEnMain(j, now, EtatJoueur.normal(), true); + } + + @Test + void autoTotemEnforceExpulseSansJamaisDeSetback() { + cfg.mode(Controle.AUTO_TOTEM, Mode.ENFORCE); + Sanction pire = Sanction.AUCUNE; + int detections = 0; + for (int k = 0; k < 6 && pire != Sanction.EXPULSION; k++) { + for (Verdict v : totem()) { + detections++; + assertTrue(v.applicable() != Sanction.SETBACK, "palier SETBACK ramene a ALERTE"); + if (v.applicable().ordinal() > pire.ordinal()) pire = v.applicable(); + } + now += 300; // detections rapprochees + } + assertEquals(Sanction.EXPULSION, pire); + assertTrue(detections <= 4, "expulsion a la 3e ou 4e detection rapprochee : " + detections); + } + + @Test + void autoTotemEnObserveJamaisDeSanction() { + for (int k = 0; k < 10; k++) { + for (Verdict v : totem()) assertTrue(v.applicable().ordinal() <= Sanction.ALERTE.ordinal()); + now += 300; + } + } + + private Sanction recul() { + now += 2000; + moteur.reculApplique(j, now, 1, 0, 0.4, true); + Sanction pire = Sanction.AUCUNE; + for (int i = 0; i < 7; i++) { + now += 50; + for (Verdict v : moteur.mesureRecul(j, now, EtatJoueur.normal(), 0, 0, false, (x, z) -> false)) { + if (v.applicable().ordinal() > pire.ordinal()) pire = v.applicable(); + } + } + return pire; + } + + @Test + void velociteEnforceSetbackPuisExpulsion() { + cfg.mode(Controle.VELOCITE, Mode.ENFORCE); + cfg.setbacksAvantExpulsion = 0; // isole les seuils de velocite (C5 teste ailleurs) + boolean setback = false; + Sanction s = Sanction.AUCUNE; + for (int k = 0; k < 20 && s != Sanction.EXPULSION; k++) { + s = recul(); + if (s == Sanction.SETBACK) setback = true; + } + assertTrue(setback, "retour en arriere avant l'expulsion"); + assertEquals(Sanction.EXPULSION, s); + } + + @Test + void velociteEnObserveJamaisDeSanction() { + for (int k = 0; k < 20; k++) assertTrue(recul().ordinal() <= Sanction.ALERTE.ordinal()); + } +}