diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 73099cd..9e475ee 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -720,6 +720,10 @@ public final class Garde { List v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em, hauteurPermise(p)); Sanction s = traiter(p, v); if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v); + // 0.5 (P2) : no-slow… (OBSERVE par défaut). Câblage non testé en jeu. + List v2 = MOTEUR.mouvementP2(p.getUUID(), tick * 50L, etatMouvement, em, faitsMouvement(p)); + Sanction s2 = traiter(p, v2); + if (Cablage.sanctionDeMouvement(s2)) appliquerSanctionMouvement(p, s2, v2); } // F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup. if (!estExempteManuellement(p.getUUID())) { @@ -908,10 +912,16 @@ 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.ANTI_FAIM) != Mode.OFF || CONFIG.mode(Controle.NO_SLOW) != Mode.OFF || CONFIG.mode(Controle.CRITICALS) != Mode.OFF; // criticals : suit la hauteur à chaque mouvement } + /** 0.5 (P2) : faits supplémentaires du paquet accepté pour {@link Moteur#mouvementP2}. */ + private static com.gastinelgarde.core.FaitsMouvement faitsMouvement(ServerPlayer p) { + return new com.gastinelgarde.core.FaitsMouvement() + .ticksUsage(p.isUsingItem() ? p.getTicksUsingItem() : -1); + } + /** * 0.5 (P1.9) : hauteur de marche permise en un tick : max(attribut step_height, puissance de saut = jump_strength * + Saut amélioré). NaN (pas de mesure step) si un piston en mouvement touche la boîte du joueur élargie d'un diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index e1576c0..0057c1a 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -27,6 +27,9 @@ public final class GardeSpec { 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; + // 0.5 (P2) + private static final ModConfigSpec.DoubleValue NO_SLOW_FACTEUR; + private static final ModConfigSpec.IntValue NO_SLOW_GRACE, NO_SLOW_TICKS; private static final ModConfigSpec.DoubleValue ANGLE_MAX; private static final ModConfigSpec.IntValue CIBLES_MAX; @@ -265,6 +268,13 @@ public final class GardeSpec { 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); + NO_SLOW_FACTEUR = b.comment("0.5 (P2.1) no-slow : vitesse au sol permise en utilisant un objet = ce facteur × course (0,30 bloc/tick) × effets.", + "Vanilla ralentit à ×0,2 (≈0,06 bloc/tick en courant) : 0,5 laisse une marge large.") + .defineInRange("noSlowFacteur", 0.5, 0.2, 2.0); + NO_SLOW_GRACE = b.comment("No-slow : ticks d'usage d'objet avant de mesurer (élan de la course).") + .defineInRange("noSlowGraceTicks", 3, 0, 40); + NO_SLOW_TICKS = b.comment("No-slow : paquets suspects consécutifs avant infraction.") + .defineInRange("noSlowTicks", 10, 2, 200); b.pop(); b.comment("0.5 : diagnostics (journal seulement, jamais de sanction).").push("diagnostic"); @@ -436,6 +446,9 @@ public final class GardeSpec { c.criticalsMicroSautMax = CRIT_MICRO.get(); c.criticalsSerieMin = CRIT_SERIE.get(); c.antiFaimTicks = ANTI_FAIM_TICKS.get(); + c.noSlowFacteur = NO_SLOW_FACTEUR.get(); + c.noSlowGraceTicks = NO_SLOW_GRACE.get(); + c.noSlowTicks = NO_SLOW_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/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index cfb826a..e3a5228 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -29,7 +29,9 @@ public enum Controle { /** 0.5 (P1.10) : coups critiques en série sans vrai saut ni vraie chute (Criticals, micro-sauts fictifs). */ 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"); + ANTI_FAIM("anti-faim"), + /** 0.5 (P2.1) : vitesse de marche ou de course gardée pendant un usage d'objet (NoSlow). */ + NO_SLOW("no-slow"); private final String id; @@ -57,7 +59,8 @@ 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, ANTI_FAIM -> 2; + case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS, ANTI_FAIM, + NO_SLOW -> 2; // 0.5 (P2) : idem }; } diff --git a/src/main/java/com/gastinelgarde/core/FaitsMouvement.java b/src/main/java/com/gastinelgarde/core/FaitsMouvement.java new file mode 100644 index 0000000..358aa33 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/FaitsMouvement.java @@ -0,0 +1,18 @@ +package com.gastinelgarde.core; + +/** + * 0.5 (P2) : faits supplémentaires d'un paquet de mouvement accepté, lus par l'adaptateur pour les contrôles P2 + * (no-slow, jesus, omnisprint). Classe à champs publics plutôt qu'un record : chaque contrôle P2 y ajoute ce dont il + * a besoin sans casser les appels existants (tests, rejeu). Valeurs par défaut = « inconnu » : le contrôle concerné ne + * mesure pas. + */ +public final class FaitsMouvement { + + /** Ticks depuis le début de l'usage d'objet en cours, vus par le serveur ({@code getTicksUsingItem}) ; -1 = inconnu. */ + public int ticksUsage = -1; + + public FaitsMouvement ticksUsage(int v) { + ticksUsage = v; + return this; + } +} diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index 5d8de32..875dd4c 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -181,6 +181,14 @@ public final class GardeConfig { /** 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; + // --- 0.5 (P2) : nouveaux contrôles, OBSERVE par défaut, valeurs prudentes à valider en jeu --- + /** NoSlow : vitesse au sol permise pendant un usage d'objet = ce facteur × course (0,30) × effets ; vanilla ~0,2. */ + public double noSlowFacteur = 0.5; + /** NoSlow : ticks d'usage d'objet (serveur) avant de mesurer (élan de la course, latence du début d'usage). */ + public int noSlowGraceTicks = 3; + /** NoSlow : paquets suspects consécutifs avant infraction. */ + public int noSlowTicks = 10; + // --- 0.5 (P1.13, section [diagnostic]) : journal seulement, jamais de sanction --- /** Journaliser les ABORT de casse de bloc sans START correspondant (« Mismatch in destroy block pos »). */ public boolean diagnosticActionsBloc = true; diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index c95746d..de16e0e 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -448,6 +448,33 @@ public final class Moteur { return verdicts; } + /** + * 0.5 (P2) : contrôles de mouvement ajoutés en P2 (no-slow…), sur le même paquet accepté que {@link #mouvement}, + * avec les faits supplémentaires lus par l'adaptateur. Appel séparé pour ne pas toucher la signature de + * {@link #mouvement} (traces, rejeu). Mêmes exemptions de mouvement : créatif, spectateur, vol permis, élytres, + * riptide, véhicule, contraption Create / vaisseau Sable, téléportation, recul, connexion ; seuils × facteurLag si + * le serveur tire. + */ + public List mouvementP2(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m, FaitsMouvement f) { + if (expulses.contains(joueur)) return new ArrayList<>(0); // C4 + boolean noSlow = cfg.mode(Controle.NO_SLOW) != Mode.OFF; + if (!noSlow) return List.of(); + Suivi s = suivi(joueur); + Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT); + if (ex.exempt() || etat.ticksDepuisGel() <= cfg.graceGelTicks) { + s.noSlow.vider(); + return List.of(); + } + List verdicts = new ArrayList<>(1); + if (noSlow) { + double pts = s.noSlow.enregistrer(m, f.ticksUsage, cfg, ex.facteur()); + ajouter(verdicts, s, Controle.NO_SLOW, pts, nowMs, ex, String.format(Locale.ROOT, + "vitesse %.3f au sol en utilisant un objet %d paquets de suite (seuil %.3f)", + s.noSlow.derniereVitesse(), cfg.noSlowTicks, NoSlow.seuil(m, cfg))); + } + return verdicts; + } + /** * L'exemption tient-elle à un état dont la fin arrive en retard côté serveur (élytres, riptide, véhicule, vol, * contraption, lévitation, chute lente, mode de jeu) ? Une grâce seule (téléportation, recul) : non. diff --git a/src/main/java/com/gastinelgarde/core/NoSlow.java b/src/main/java/com/gastinelgarde/core/NoSlow.java new file mode 100644 index 0000000..fd0cf78 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/NoSlow.java @@ -0,0 +1,63 @@ +package com.gastinelgarde.core; + +/** + * 0.5 (P2.1) : NoSlow. Vanilla 1.21.1 (LocalPlayer.aiStep, côté client) multiplie l'entrée de déplacement par 0,2 tant + * que le joueur utilise un objet (manger, boire, bander un arc ou une arbalète, bloquer au bouclier, charger un + * trident, longue-vue…). Le serveur ne ralentit rien lui-même : le cheat garde sa vitesse de marche ou de course. + * + * Ordres de grandeur au sol (friction 0,6) : marche 0,216 bloc/tick, course 0,281 ; en usage d'objet ×0,2, soit + * ~0,043 en marchant et ~0,056 si le sprint continue (vanilla ne coupe pas un sprint déjà lancé). Le seuil par défaut + * ({@link GardeConfig#noSlowFacteur} 0,5 × course 0,30 = 0,15 bloc/tick, multiplié par les effets de vitesse) laisse + * donc une marge de plus de ×2,5 au joueur honnête ; le cheat (0,22 à 0,28) le dépasse. + * + * Ne mesure que des paquets d'un tick, au sol serveur, sans déplacement vertical (un saut en mangeant garde l'élan du + * sprint-saut), hors milieu spécial et friction anormale (glace, slime, âmes), après {@link GardeConfig#noSlowGraceTicks} + * ticks d'usage (l'élan de la course décroît en 2 ou 3 ticks) et au moins {@link #SOL_MIN} paquets au sol de suite + * (atterrissage). Infraction après {@link GardeConfig#noSlowTicks} paquets suspects consécutifs. OBSERVE par défaut. + */ +public final class NoSlow { + + /** Paquets au sol consécutifs exigés avant de mesurer (élan d'un atterrissage). */ + static final int SOL_MIN = 3; + + private int serie; + private int solConsecutifs; + private double derniereVitesse; + + /** + * @param ticksUsage ticks d'usage d'objet vus par le serveur (-1 inconnu) + * @param facteur tolérance (serveur qui tire : facteurLag) + * @return points d'infraction (0 si rien) + */ + public double enregistrer(EtatMouvement m, int ticksUsage, GardeConfig cfg, double facteur) { + boolean solPlat = m.auSolServeur() && m.ticks() == 1 && Math.abs(m.dy()) < 1e-6; + solConsecutifs = solPlat ? solConsecutifs + 1 : 0; + boolean mesurable = m.ralentiParObjet() && ticksUsage >= 0 && ticksUsage > cfg.noSlowGraceTicks && solPlat + && solConsecutifs >= SOL_MIN && !m.milieuSpecial() && !m.frictionAnormale(); + if (!mesurable || m.dxz() <= seuil(m, cfg) * Math.max(1.0, facteur)) { + serie = 0; + return 0; + } + derniereVitesse = m.dxz(); + if (++serie < Math.max(1, cfg.noSlowTicks)) return 0; + serie = 0; // une infraction par série complète + return 2.0; + } + + /** Vitesse au sol permise pendant un usage d'objet (blocs/tick), effets de vitesse compris. */ + public static double seuil(EtatMouvement m, GardeConfig cfg) { + double effets = 1.0 + 0.2 * Math.max(0, m.amplificateurVitesse()); + double f = m.facteurVitesse(); + if (!Double.isNaN(f) && !Double.isInfinite(f) && f > effets) effets = f; + return cfg.noSlowFacteur * VitesseHorizontale.COURSE * effets; + } + + public double derniereVitesse() { + return derniereVitesse; + } + + public void vider() { + serie = 0; + solConsecutifs = 0; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index e69193d..55935a5 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -65,6 +65,8 @@ public final class Suivi { public final Criticals criticals = new Criticals(); /** 0.5 (P1.8) : anti-faim. */ public final AntiFaim antiFaim = new AntiFaim(); + /** 0.5 (P2.1) : no-slow. */ + public final NoSlow noSlow = new NoSlow(); /** 0.5 (P1.6) : déploiements d'élytres répétés. */ public final DeploiementsElytres deploiements = new DeploiementsElytres(); /** 0.5 (P1.13) : diagnostic des actions de casse de bloc. */ diff --git a/src/test/java/com/gastinelgarde/core/NoSlowP2Test.java b/src/test/java/com/gastinelgarde/core/NoSlowP2Test.java new file mode 100644 index 0000000..e94ebfd --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/NoSlowP2Test.java @@ -0,0 +1,100 @@ +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 java.util.function.IntFunction; +import org.junit.jupiter.api.Test; + +/** 0.5, P2.1 : no-slow (vitesse gardée pendant un usage d'objet). */ +class NoSlowP2Test { + + private final GardeConfig cfg = new GardeConfig(); + private final UUID joueur = UUID.randomUUID(); + + /** Paquet d'un tick au sol plat, en utilisant un objet, à la vitesse dxz. */ + private static EtatMouvement usage(double dxz, int vitesse) { + return new EtatMouvement(dxz, 0, 1, true, true, true, false, true, vitesse, 0, false, false); + } + + private double total(Moteur m, EtatJoueur etat, int paquets, IntFunction f, int graceUsage) { + double pts = 0; + for (int i = 0; i < paquets; i++) { + FaitsMouvement faits = new FaitsMouvement().ticksUsage(i + graceUsage); + for (Verdict v : m.mouvementP2(joueur, (i + 1) * 50L, etat, f.apply(i), faits)) { + if (v.controle() == Controle.NO_SLOW) pts += v.points(); + } + } + return pts; + } + + @Test + void observeParDefautEtFiabiliteFaible() { + assertEquals(Mode.OBSERVE, cfg.mode(Controle.NO_SLOW)); + assertEquals(Controle.NO_SLOW, Controle.parse("no-slow")); + assertEquals(2, Controle.NO_SLOW.fiabilite()); + } + + @Test + void courseEnMangeantVue() { + // 0,28 bloc/tick (course vanilla) en mangeant, 20 paquets : au moins une infraction. + assertTrue(total(new Moteur(cfg), EtatJoueur.normal(), 20, i -> usage(0.28, 0), 0) > 0); + } + + @Test + void joueurHonneteJamaisVu() { + // Vanilla : ×0,2, sprint gardé = ~0,056 bloc/tick ; avec Vitesse II, ~0,08. + assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 200, i -> usage(0.06, 0), 0), 1e-9); + assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 200, i -> usage(0.08, 2), 0), 1e-9); + } + + @Test + void elanDuDebutDUsageIgnore() { + // Les 3 premiers ticks d'usage (élan de la course) ne comptent pas : 3 + 9 paquets rapides = pas encore 10. + assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 12, i -> usage(0.28, 0), -2), 1e-9); + } + + @Test + void sautGlaceMilieuEtPaquetsGroupesNeComptentPas() { + // Saut (dy != 0), glace, eau, plusieurs ticks entre deux paquets : rien. + assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40, + i -> new EtatMouvement(0.28, i % 2 == 0 ? 0.42 : 0, 1, false, i % 2 != 0, true, false, true, 0, 0, false, false), 0), 1e-9); + assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40, + i -> new EtatMouvement(0.28, 0, 1, true, true, true, false, true, 0, 0, false, true), 0), 1e-9); + assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40, + i -> new EtatMouvement(0.28, 0, 1, true, true, true, false, true, 0, 0, true, false), 0), 1e-9); + assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40, + i -> new EtatMouvement(0.56, 0, 2, true, true, true, false, true, 0, 0, false, false), 0), 1e-9); + } + + @Test + void sansUsageDObjetRien() { + assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40, + i -> new EtatMouvement(0.28, 0, 1, true, true, true, false, false, 0, 0, false, false), 0), 1e-9); + // usage inconnu (-1) : pas de mesure + Moteur m = new Moteur(cfg); + double pts = 0; + for (int i = 0; i < 40; i++) { + for (Verdict v : m.mouvementP2(joueur, i * 50L, EtatJoueur.normal(), usage(0.28, 0), new FaitsMouvement())) pts += v.points(); + } + assertEquals(0, pts, 1e-9); + } + + @Test + void exemptions() { + for (EtatJoueur e : new EtatJoueur[] { + EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build(), + EtatJoueur.builder().enVehicule(true).build(), EtatJoueur.builder().pocheContraption(true).build(), + EtatJoueur.builder().ticksDepuisRecul(1).build(), EtatJoueur.builder().ticksDepuisGel(5).build(), + EtatJoueur.builder().connexionRecente(true).build()}) { + assertEquals(0, total(new Moteur(cfg), e, 40, i -> usage(0.28, 0), 0), 1e-9, e.toString()); + } + } + + @Test + void offNeMesureRien() { + cfg.mode(Controle.NO_SLOW, Mode.OFF); + assertEquals(0, total(new Moteur(cfg), EtatJoueur.normal(), 40, i -> usage(0.28, 0), 0), 1e-9); + } +}