P1.9 : nouveau controle step (OBSERVE par defaut)

- 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 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Sonnet 5.5 a révisé 2026-10-24 00:30:22 +02:00
1 Parent d7a6772c42
révision 50b3f211a3
8 fichiers modifiés
+217 -5

Aucun fichier ne correspond à votre recherche

+20 -2
Voir le fichier
@@ -690,7 +690,7 @@ public final class Garde {
etatMouvement = etat(p, true);
}
if (controler && em != null) {
List<Verdict> v = MOTEUR.mouvement(p.getUUID(), tick * 50L, etatMouvement, em);
List<Verdict> 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);
}
/**
+8
Voir le fichier
@@ -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();
+5 -2
Voir le fichier
@@ -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;
};
}
+6
Voir le fichier
@@ -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. */
+16 -1
Voir le fichier
@@ -368,15 +368,25 @@ public final class Moteur {
* Les exemptions de mouvement (riptide, élytres, contraption, téléportation, recul…) coupent tout.
*/
public List<Verdict> 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<Verdict> 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;
}
+52
Voir le fichier
@@ -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;
}
}
+2
Voir le fichier
@@ -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());
+108
Voir le fichier
@@ -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<Verdict> 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<Verdict> 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);
}
}