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 à :
1 Parent
d7a6772c42
révision
50b3f211a3
8 fichiers modifiés
+217
-5
Aucun fichier ne correspond à votre recherche
@@ -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);
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -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. */
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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());
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur