From 50b3f211a3abd74cd5ec5d438bd79a7768e4d576 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Sat, 24 Oct 2026 00:30:22 +0200 Subject: [PATCH] P1.9 : nouveau controle step (OBSERVE par defaut) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - core.Step : au sol serveur au paquet precedent et a celui-ci, en un seul tick, gain > max(stepHauteurMax, attribut step_height, saut) + marge. Valeurs vanilla verifiees dans les sources NeoForge 21.1.234 : step_height 0,6 ; jump_strength 0,42 ; +0,1 par niveau de Saut ameliore. - Pas de mesure : plusieurs ticks entre deux paquets, milieu special, exemption de mouvement, piston en mouvement autour du joueur (NaN), ancienne signature de Moteur.mouvement (traces, rejeu). - Reglages [mouvement] : stepHauteurMax (0.6), stepMargeBlocs (0.1). Fiabilite « faible » (plafond 15 du score). - Tests : StepP1Test. Co-Authored-By: Claude Sonnet 5.5 --- src/main/java/com/gastinelgarde/Garde.java | 22 +++- .../java/com/gastinelgarde/GardeSpec.java | 8 ++ .../java/com/gastinelgarde/core/Controle.java | 7 +- .../com/gastinelgarde/core/GardeConfig.java | 6 + .../java/com/gastinelgarde/core/Moteur.java | 17 ++- .../java/com/gastinelgarde/core/Step.java | 52 +++++++++ .../java/com/gastinelgarde/core/Suivi.java | 2 + .../com/gastinelgarde/core/StepP1Test.java | 108 ++++++++++++++++++ 8 files changed, 217 insertions(+), 5 deletions(-) create mode 100644 src/main/java/com/gastinelgarde/core/Step.java create mode 100644 src/test/java/com/gastinelgarde/core/StepP1Test.java diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 208203b..a59c564 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -690,7 +690,7 @@ public final class Garde { etatMouvement = etat(p, true); } if (controler && em != null) { - List v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em); + 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); } @@ -872,7 +872,25 @@ 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.VOL) != Mode.OFF || CONFIG.mode(Controle.STEP) != Mode.OFF; + } + + /** + * 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 + * bloc : un piston peut soulever un joueur d'un bloc entre deux paquets [À VÉRIFIER en jeu]. + */ + private static double hauteurPermise(ServerPlayer p) { + if (CONFIG.mode(Controle.STEP) == Mode.OFF) return Double.NaN; + net.minecraft.world.phys.AABB b = p.getBoundingBox().inflate(1.0); + for (BlockPos q : BlockPos.betweenClosed(net.minecraft.util.Mth.floor(b.minX), net.minecraft.util.Mth.floor(b.minY), + net.minecraft.util.Mth.floor(b.minZ), net.minecraft.util.Mth.floor(b.maxX), + net.minecraft.util.Mth.floor(b.maxY), net.minecraft.util.Mth.floor(b.maxZ))) { + if (p.level().getBlockState(q).is(Blocks.MOVING_PISTON)) return Double.NaN; + } + double marche = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.STEP_HEIGHT); + double saut = p.getAttributeValue(net.minecraft.world.entity.ai.attributes.Attributes.JUMP_STRENGTH) + p.getJumpBoostPower(); + return Math.max(marche, saut); } /** diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index 415fa63..a127476 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -24,6 +24,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; private static final ModConfigSpec.IntValue JOURNAL_LIMITE; private static final ModConfigSpec.DoubleValue ANGLE_MAX; @@ -247,6 +248,11 @@ public final class GardeSpec { 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); b.pop(); b.comment("0.5 : grâces à la connexion (reconnexion en l'air, expulsion récente).").push("graces"); @@ -405,6 +411,8 @@ public final class GardeSpec { 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.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 abf8e25..00a4af1 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -23,7 +23,9 @@ public enum Controle { /** 0.4.0 : recul absent après un coup subi (Anti Knockback, Anti Push). */ VELOCITE("velocite"), /** 0.4.0 : totem remis en main sans délai humain après l'éclatement (Auto Totem). */ - AUTO_TOTEM("auto-totem"); + AUTO_TOTEM("auto-totem"), + /** 0.5 (P1.9) : marche plus haute que la hauteur permise en un tick, au sol avant et après (Step / HighStep). */ + STEP("step"); private final String id; @@ -50,7 +52,8 @@ public enum Controle { return switch (this) { 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; - case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE -> 2; + // 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 -> 2; }; } diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index f4d4c22..41ce451 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -167,6 +167,12 @@ public final class GardeConfig { /** 0.5 (P1.12) : crédit (paquets en retard) au plus remboursable par une rafale de rattrapage après un lag. */ public int timerDetteMax = 40; + // --- 0.5 (P1) : nouveaux contrôles, OBSERVE par défaut, valeurs prudentes à valider en jeu --- + /** Step : hauteur de marche au moins permise (vanilla : attribut step_height, 0,6) ; l'attribut réel du joueur et sa puissance de saut s'ajoutent (maximum). */ + public double stepHauteurMax = 0.6; + /** Step : marge (blocs) au-dessus de la hauteur permise. */ + public double stepMargeBlocs = 0.1; + // --- Exemptions --- public int graceTeleportTicks = 40; /** 0.5 (P1.2) : grâce de mouvement / timer après la connexion (ticks) ; plus longue après une expulsion récente. */ diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index c6a3389..2745c74 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -368,15 +368,25 @@ public final class Moteur { * Les exemptions de mouvement (riptide, élytres, contraption, téléportation, recul…) coupent tout. */ public List mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m) { + return mouvement(joueur, nowMs, etat, m, Double.NaN); + } + + /** + * Idem, avec la hauteur de marche permise du joueur pour le contrôle step (0.5, P1.9) : max(attribut step_height, + * puissance de saut). NaN = inconnue (traces, rejeu, piston proche) : step ne mesure pas. + */ + public List mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m, double hauteurPermise) { if (expulses.contains(joueur)) return new ArrayList<>(0); // C4 boolean noFall = cfg.mode(Controle.NO_FALL) != Mode.OFF; boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF; boolean vol = cfg.mode(Controle.VOL) != Mode.OFF; - if (!noFall && !vitesse && !vol) return List.of(); + boolean step = cfg.mode(Controle.STEP) != Mode.OFF; + if (!noFall && !vitesse && !vol && !step) return List.of(); Suivi s = suivi(joueur); Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT); if (ex.exempt()) { + s.step.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(); @@ -422,6 +432,11 @@ public final class Moteur { double pts = s.vol.enregistrer(m, false); ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy())); } + if (step) { + double pts = s.step.enregistrer(m, hauteurPermise, cfg); + 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))); + } return verdicts; } diff --git a/src/main/java/com/gastinelgarde/core/Step.java b/src/main/java/com/gastinelgarde/core/Step.java new file mode 100644 index 0000000..dc43f96 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/Step.java @@ -0,0 +1,52 @@ +package com.gastinelgarde.core; + +/** + * 0.5 (P1.9) : Step / HighStep. Un joueur au sol (vu par le serveur) au paquet précédent et à celui-ci, qui a gagné + * en un seul tick plus que la hauteur de marche permise. + * + * Valeurs vanilla 1.21.1 (vérifiées dans les sources décompilées de NeoForge 21.1.234, Attributes.java et + * LivingEntity.getJumpPower) : attribut {@code generic.step_height} 0,6 par défaut ; saut = attribut + * {@code generic.jump_strength} (0,42) × facteur de saut du bloc + 0,1 par niveau de Saut amélioré. Un saut ne + * donne jamais plus que sa puissance en un tick : la hauteur permise est le maximum des deux (fournie par + * l'adaptateur), plus une marge. Escaliers, dalles, chemins, lits (≤ 0,6) ne comptent donc jamais. + * + * Ce que le contrôle ne voit pas (volontairement) : plusieurs ticks entre deux paquets (le gain est réparti), + * milieux spéciaux (échelle, eau…), hauteur permise inconnue (piston en mouvement à proximité : l'adaptateur passe + * NaN). OBSERVE par défaut. + */ +public final class Step { + + private boolean connu; + private boolean solAvant; + private double dernierGain; + + /** + * @param hauteurPermise max(step_height, puissance de saut) du joueur ; NaN = inconnue, pas de mesure + * @return points d'infraction (0 si rien) + */ + public double enregistrer(EtatMouvement m, double hauteurPermise, GardeConfig cfg) { + boolean avant = connu && solAvant; + connu = true; + solAvant = m.auSolServeur(); + if (!avant || !m.auSolServeur() || m.ticks() != 1 || m.milieuSpecial() || Double.isNaN(hauteurPermise)) return 0; + double seuil = seuil(hauteurPermise, cfg); + if (m.dy() <= seuil) return 0; + dernierGain = m.dy(); + // 2 points par marche anormale, jusqu'à 5 pour un gain d'un bloc et plus au-delà du seuil. + return 2.0 + Math.min(3.0, (m.dy() - seuil) * 3.0); + } + + public static double seuil(double hauteurPermise, GardeConfig cfg) { + return Math.max(cfg.stepHauteurMax, hauteurPermise) + Math.max(0, cfg.stepMargeBlocs); + } + + public double dernierGain() { + return dernierGain; + } + + /** Période exemptée, téléportation : le paquet suivant sert de référence. */ + public void vider() { + connu = false; + solAvant = false; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index 8b5234e..9c5fd83 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -59,6 +59,8 @@ public final class Suivi { public final PlaneElytres plane = new PlaneElytres(); public final Velocite velocite = new Velocite(); public final AutoTotem totem = new AutoTotem(); + /** 0.5 (P1) : step. */ + public final Step step = new Step(); public Suivi(double decroissanceParSeconde) { this(decroissanceParSeconde, new GardeConfig()); diff --git a/src/test/java/com/gastinelgarde/core/StepP1Test.java b/src/test/java/com/gastinelgarde/core/StepP1Test.java new file mode 100644 index 0000000..421390d --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/StepP1Test.java @@ -0,0 +1,108 @@ +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.Test; + +/** 0.5, P1.9 : step (marche trop haute en un tick, au sol avant et après). */ +class StepP1Test { + + private final GardeConfig cfg = new GardeConfig(); + private final UUID joueur = UUID.randomUUID(); + /** Joueur vanilla : max(step_height 0,6, saut 0,42). */ + private static final double VANILLA = 0.6; + + private static EtatMouvement sol(double dy, boolean solServeur) { + return new EtatMouvement(0.2, dy, 1, solServeur, solServeur, false, false, false, 0, 0, false, false); + } + + private double step(Moteur m, double hauteur, EtatMouvement... suite) { + double total = 0; + long t = 0; + for (EtatMouvement e : suite) { + t += 50; + for (Verdict v : m.mouvement(joueur, t, EtatJoueur.normal(), e, hauteur)) { + if (v.controle() == Controle.STEP) total += v.points(); + } + } + return total; + } + + @Test + void observeParDefaut() { + assertEquals(Mode.OBSERVE, cfg.mode(Controle.STEP)); + assertEquals(2, Controle.STEP.fiabilite(), "plafond faible du score"); + assertEquals(Controle.STEP, Controle.parse("step")); + } + + @Test + void unBlocEnUnTickAuSolEstVu() { + assertTrue(step(new Moteur(cfg), VANILLA, sol(0, true), sol(1.0, true)) > 0); + } + + @Test + void dallesEscaliersEtLitsNeComptentPas() { + Moteur m = new Moteur(cfg); + assertEquals(0, step(m, VANILLA, sol(0, true), sol(0.5, true), sol(0.5, true), sol(0.5625, true), sol(0.6, true)), 1e-9); + assertEquals(0, step(m, VANILLA, sol(0, true), sol(0.69, true)), 1e-9, "dans la marge"); + } + + @Test + void attributStepOuSautAmelioreReleveLeSeuil() { + assertEquals(0, step(new Moteur(cfg), 1.0, sol(0, true), sol(1.0, true)), 1e-9, "attribut step_height 1,0"); + // Saut amélioré V : 0,42 + 0,5 = 0,92 en un tick ; atterrir sur un bloc de 0,9 n'est pas un step. + assertEquals(0, step(new Moteur(cfg), 0.92, sol(0, true), sol(0.9, true)), 1e-9); + } + + @Test + void sautOrdinaireEtAirPasMesures() { + // Saut : en l'air après le premier tick (sol serveur faux), puis retombée sur un bloc. + Moteur m = new Moteur(cfg); + assertEquals(0, step(m, VANILLA, sol(0, true), sol(0.42, false), sol(0.33, false), sol(0.25, true)), 1e-9); + // Pas de sol au paquet précédent : rien + assertEquals(0, step(new Moteur(cfg), VANILLA, sol(0, false), sol(1.0, true)), 1e-9); + } + + @Test + void plusieursTicksMilieuSpecialOuHauteurInconnuePasMesures() { + EtatMouvement deuxTicks = new EtatMouvement(0.4, 1.0, 2, true, true, false, false, false, 0, 0, false, false); + assertEquals(0, step(new Moteur(cfg), VANILLA, sol(0, true), deuxTicks), 1e-9); + EtatMouvement echelle = new EtatMouvement(0, 1.0, 1, true, true, false, false, false, 0, 0, true, false); + assertEquals(0, step(new Moteur(cfg), VANILLA, sol(0, true), echelle), 1e-9); + assertEquals(0, step(new Moteur(cfg), Double.NaN, sol(0, true), sol(1.0, true)), 1e-9, "piston proche"); + // L'ancienne signature (traces, rejeu) ne mesure jamais step. + Moteur m = new Moteur(cfg); + m.mouvement(joueur, 50, EtatJoueur.normal(), sol(0, true)); + List v = m.mouvement(joueur, 100, EtatJoueur.normal(), sol(1.0, true)); + assertTrue(v.stream().noneMatch(x -> x.controle() == Controle.STEP)); + } + + @Test + void exemptionCoupeEtRemetLaReferenceAZero() { + Moteur m = new Moteur(cfg); + m.mouvement(joueur, 50, EtatJoueur.normal(), sol(0, true), VANILLA); + EtatJoueur teleport = EtatJoueur.builder().ticksDepuisTeleport(1).build(); + assertTrue(m.mouvement(joueur, 100, teleport, sol(1.0, true), VANILLA).isEmpty()); + // Juste après l'exemption : pas de référence, le gain n'est pas compté. + List v = m.mouvement(joueur, 150, EtatJoueur.normal(), sol(1.0, true), VANILLA); + assertTrue(v.stream().noneMatch(x -> x.controle() == Controle.STEP)); + } + + @Test + void enObserveJamaisDeSanction() { + Moteur m = new Moteur(cfg); + Sanction pire = Sanction.AUCUNE; + long t = 0; + for (int i = 0; i < 40; i++) { + t += 50; + m.mouvement(joueur, t, EtatJoueur.normal(), sol(0, true), VANILLA); + t += 50; + Sanction s = Verdict.pire(m.mouvement(joueur, t, EtatJoueur.normal(), sol(1.2, true), VANILLA)); + if (s.ordinal() > pire.ordinal()) pire = s; + } + assertTrue(pire.ordinal() <= Sanction.ALERTE.ordinal(), "OBSERVE : au plus une alerte, " + pire); + } +}