From fc34047e65db71a176b8f716a23438bf46711aa9 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Sat, 24 Oct 2026 00:33:52 +0200 Subject: [PATCH] P1.8 : nouveau controle anti-faim (OBSERVE par defaut) - core.AntiFaim : antiFaimTicks (20) paquets de suite ou le serveur voit le joueur courir au sol sur du plat (dy nul, dxz >= 0,1, un tick) alors que le client se declare en l'air. Vanilla (ServerPlayer.checkMovementStatistics, verifie dans les sources NeoForge 21.1.234) ne compte la faim de course que si onGround, drapeau venu du client. - Exemptions de mouvement, milieux speciaux, plusieurs ticks : pas de mesure. - Reglage [mouvement] : antiFaimTicks. - Tests : AntiFaimP1Test. Co-Authored-By: Claude Sonnet 5.5 --- src/main/java/com/gastinelgarde/Garde.java | 1 + .../java/com/gastinelgarde/GardeSpec.java | 6 +- .../java/com/gastinelgarde/core/AntiFaim.java | 35 ++++++++++ .../java/com/gastinelgarde/core/Controle.java | 6 +- .../com/gastinelgarde/core/GardeConfig.java | 2 + .../java/com/gastinelgarde/core/Moteur.java | 8 ++- .../java/com/gastinelgarde/core/Suivi.java | 2 + .../gastinelgarde/core/AntiFaimP1Test.java | 69 +++++++++++++++++++ 8 files changed, 125 insertions(+), 4 deletions(-) create mode 100644 src/main/java/com/gastinelgarde/core/AntiFaim.java create mode 100644 src/test/java/com/gastinelgarde/core/AntiFaimP1Test.java diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index c853e12..da8eca4 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -884,6 +884,7 @@ public final class Garde { private static boolean mouvementControlesActifs() { return CONFIG.mode(Controle.NO_FALL) != Mode.OFF || CONFIG.mode(Controle.VITESSE) != Mode.OFF || CONFIG.mode(Controle.VOL) != Mode.OFF || CONFIG.mode(Controle.STEP) != Mode.OFF + || CONFIG.mode(Controle.ANTI_FAIM) != Mode.OFF || CONFIG.mode(Controle.CRITICALS) != Mode.OFF; // criticals : suit la hauteur à chaque mouvement } diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index aca4a38..c1ea970 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -25,7 +25,7 @@ public final class GardeSpec { private static final ModConfigSpec.BooleanValue JOURNAL_TOUJOURS, SETBACK_SOL; 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; + private static final ModConfigSpec.IntValue CRIT_SERIE, ANTI_FAIM_TICKS; private static final ModConfigSpec.IntValue JOURNAL_LIMITE; private static final ModConfigSpec.DoubleValue ANGLE_MAX; @@ -259,6 +259,9 @@ public final class GardeSpec { .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 : grâces à la connexion (reconnexion en l'air, expulsion récente).").push("graces"); @@ -421,6 +424,7 @@ public final class GardeSpec { 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(); diff --git a/src/main/java/com/gastinelgarde/core/AntiFaim.java b/src/main/java/com/gastinelgarde/core/AntiFaim.java new file mode 100644 index 0000000..b97a666 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/AntiFaim.java @@ -0,0 +1,35 @@ +package com.gastinelgarde.core; + +/** + * 0.5 (P1.8) : anti-faim (AntiHunger). Vanilla 1.21.1 (ServerPlayer.checkMovementStatistics, vérifié dans les + * sources NeoForge 21.1.234) ne fait perdre de la faim à la course (0,1 par bloc) que si {@code onGround()}, drapeau + * recopié du paquet du CLIENT. Le cheat déclare « pas au sol » en courant sur un sol plat : aucune faim perdue. + * + * Signal : {@link GardeConfig#antiFaimTicks} paquets consécutifs où le serveur voit le joueur courir (sprint) au sol, + * sans aucun déplacement vertical, avec un vrai déplacement horizontal, alors que le client se dit en l'air. Un + * joueur honnête qui court sur du plat se déclare au sol à chaque paquet ; un saut a toujours dy ≠ 0. Plusieurs + * ticks entre deux paquets ou un milieu spécial coupent la série. OBSERVE par défaut. + */ +public final class AntiFaim { + + /** Déplacement horizontal minimal par tick pour compter (la marche lente ne coûte rien de toute façon). */ + static final double DXZ_MIN = 0.1; + + private int serie; + + public double enregistrer(EtatMouvement m, GardeConfig cfg) { + boolean suspect = m.sprint() && !m.auSolClient() && m.auSolServeur() && Math.abs(m.dy()) < 1e-6 + && m.ticks() == 1 && m.dxz() >= DXZ_MIN && !m.milieuSpecial(); + if (!suspect) { + serie = 0; + return 0; + } + if (++serie < Math.max(1, cfg.antiFaimTicks)) return 0; + serie = 0; // une infraction par série complète + return 2.0; + } + + public void vider() { + serie = 0; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index 19c0d2d..cfb826a 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -27,7 +27,9 @@ public enum Controle { /** 0.5 (P1.9) : marche plus haute que la hauteur permise en un tick, au sol avant et après (Step / HighStep). */ STEP("step"), /** 0.5 (P1.10) : coups critiques en série sans vrai saut ni vraie chute (Criticals, micro-sauts fictifs). */ - CRITICALS("criticals"); + CRITICALS("criticals"), + /** 0.5 (P1.8) : course au sol déclarée « en l'air » par le client pour ne pas perdre de faim (AntiHunger). */ + ANTI_FAIM("anti-faim"); private final String id; @@ -55,7 +57,7 @@ public enum Controle { case VOL, VITESSE, NO_FALL, PORTEE, HITBOX, REGULARITE, AUTO_TOTEM -> 0; // AUTO_TOTEM : 0.4.1 case COUPS_HORS_BOITE, KILLAURA_ANGLE, KILLAURA_CIBLES, CADENCE -> 1; // 0.5 : nouveaux contrôles P1 au plafond « faible » tant qu'ils n'ont pas été validés en jeu. - case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS -> 2; + case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS, ANTI_FAIM -> 2; }; } diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index 4e99143..4d302b5 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -176,6 +176,8 @@ public final class GardeConfig { public double criticalsMicroSautMax = 0.1; /** Criticals : coups critiques suspects, parmi les 10 derniers en 60 s, à partir desquels un critique suspect compte. */ public int criticalsSerieMin = 3; + /** Anti-faim : paquets consécutifs de course au sol déclarée « en l'air » avant infraction (1 s à 20 paquets/s). */ + public int antiFaimTicks = 20; // --- Exemptions --- public int graceTeleportTicks = 40; diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index b6327db..255b272 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -382,13 +382,15 @@ public final class Moteur { boolean vol = cfg.mode(Controle.VOL) != Mode.OFF; boolean step = cfg.mode(Controle.STEP) != Mode.OFF; boolean criticals = cfg.mode(Controle.CRITICALS) != Mode.OFF; - if (!noFall && !vitesse && !vol && !step && !criticals) return List.of(); + boolean antiFaim = cfg.mode(Controle.ANTI_FAIM) != Mode.OFF; + if (!noFall && !vitesse && !vol && !step && !criticals && !antiFaim) return List.of(); Suivi s = suivi(joueur); if (criticals) s.criticals.mouvement(m); // 0.5 (P1.10) : hauteur suivie même pendant une exemption Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT); if (ex.exempt()) { s.step.vider(); + s.antiFaim.vider(); // 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…). s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons())); s.vol.vider(); @@ -439,6 +441,10 @@ public final class Moteur { ajouter(verdicts, s, Controle.STEP, pts, nowMs, ex, String.format(Locale.ROOT, "marche de %.3f en un tick au sol (seuil %.2f)", m.dy(), Step.seuil(hauteurPermise, cfg))); } + if (antiFaim) { + ajouter(verdicts, s, Controle.ANTI_FAIM, s.antiFaim.enregistrer(m, cfg), nowMs, ex, String.format(Locale.ROOT, + "course au sol declaree en l'air %d paquets de suite (dxz=%.3f)", cfg.antiFaimTicks, m.dxz())); + } return verdicts; } diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index 7898861..e12f091 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -63,6 +63,8 @@ public final class Suivi { public final Step step = new Step(); /** 0.5 (P1.10) : criticals. */ public final Criticals criticals = new Criticals(); + /** 0.5 (P1.8) : anti-faim. */ + public final AntiFaim antiFaim = new AntiFaim(); public Suivi(double decroissanceParSeconde) { this(decroissanceParSeconde, new GardeConfig()); diff --git a/src/test/java/com/gastinelgarde/core/AntiFaimP1Test.java b/src/test/java/com/gastinelgarde/core/AntiFaimP1Test.java new file mode 100644 index 0000000..c1bad7c --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/AntiFaimP1Test.java @@ -0,0 +1,69 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.UUID; +import org.junit.jupiter.api.Test; + +/** 0.5, P1.8 : anti-faim (course au sol déclarée « en l'air »). */ +class AntiFaimP1Test { + + private final GardeConfig cfg = new GardeConfig(); + private final UUID joueur = UUID.randomUUID(); + + /** Course à 0,28 bloc/tick sur du plat (sprint vanilla), sol serveur vrai. */ + private static EtatMouvement course(boolean solClient, double dy) { + return new EtatMouvement(0.28, dy, 1, solClient, true, true, false, false, 0, 0, false, false); + } + + private double total(Moteur m, int paquets, java.util.function.IntFunction f) { + double pts = 0; + for (int i = 0; i < paquets; i++) { + for (Verdict v : m.mouvement(joueur, (i + 1) * 50L, EtatJoueur.normal(), f.apply(i))) { + if (v.controle() == Controle.ANTI_FAIM) pts += v.points(); + } + } + return pts; + } + + @Test + void observeParDefaut() { + assertEquals(Mode.OBSERVE, cfg.mode(Controle.ANTI_FAIM)); + assertEquals(Controle.ANTI_FAIM, Controle.parse("anti-faim")); + } + + @Test + void courseDeclareeEnLAirVue() { + assertTrue(total(new Moteur(cfg), 20, i -> course(false, 0)) > 0, "20 paquets de suite"); + assertEquals(0, total(new Moteur(cfg), 19, i -> course(false, 0)), 1e-9, "19 : pas encore"); + } + + @Test + void courseHonneteEtSautsRien() { + assertEquals(0, total(new Moteur(cfg), 200, i -> course(true, 0)), 1e-9, "au sol déclaré"); + // Sprint-saut : en l'air avec dy non nul, puis au sol. + double[] saut = {0.42, 0.333, 0.248, 0.165, 0.083, 0.0, -0.078, -0.155, -0.23, -0.303, -0.375, -0.13}; + assertEquals(0, total(new Moteur(cfg), 240, i -> { + int k = i % (saut.length + 1); + return k == saut.length ? course(true, 0) : course(false, saut[k]); + }), 1e-9); + } + + @Test + void uneInterruptionRemetLaSerieAZero() { + assertEquals(0, total(new Moteur(cfg), 200, i -> i % 15 == 14 ? course(true, 0) : course(false, 0)), 1e-9); + } + + @Test + void sansSprintMarcheLenteOuMilieuSpecialRien() { + EtatMouvement marche = new EtatMouvement(0.21, 0, 1, false, true, false, false, false, 0, 0, false, false); + assertEquals(0, total(new Moteur(cfg), 100, i -> marche), 1e-9, "marche : vanilla ne coûte rien"); + EtatMouvement lente = new EtatMouvement(0.05, 0, 1, false, true, true, false, false, 0, 0, false, false); + assertEquals(0, total(new Moteur(cfg), 100, i -> lente), 1e-9); + EtatMouvement eau = new EtatMouvement(0.28, 0, 1, false, true, true, false, false, 0, 0, true, false); + assertEquals(0, total(new Moteur(cfg), 100, i -> eau), 1e-9); + EtatMouvement airServeur = new EtatMouvement(0.28, 0, 1, false, false, true, false, false, 0, 0, false, false); + assertEquals(0, total(new Moteur(cfg), 100, i -> airServeur), 1e-9, "en l'air aussi pour le serveur : vol"); + } +}