P1.10 : nouveau controle criticals (OBSERVE par defaut)
- core.Criticals : hauteur suivie depuis le dernier « au sol » du client ; au coup critique vanilla (CriticalHitEvent.isVanillaCritical), suspect si ni montee ni descente au-dela de criticalsMicroSautMax (0,1). Points seulement en serie (criticalsSerieMin = 3 sur les 10 derniers en 60 s). Conditions vanilla du critique verifiees dans Player.attack (NeoForge 21.1.234). - ENFORCE : au palier SETBACK le critique est annule (multiplicateur 1) ; l'expulsion s'applique comme pour le combat. Exemptions de combat. - Reglages [combat] : criticalsMicroSautMax, criticalsSerieMin. - Tests : CriticalsP1Test. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
50b3f211a3
révision
23dc2bca12
9 fichiers modifiés
+257
-5
Aucun fichier ne correspond à votre recherche
@@ -397,6 +397,17 @@ public final class Garde {
|
||||
MOTEUR.estExpulse(p.getUUID()), estExempteManuellement(p.getUUID())));
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P1.10) : coup critique vanilla accordé à ce joueur. Renvoie vrai si le critique doit être annulé (contrôle
|
||||
* criticals en ENFORCE, palier SETBACK ou plus) ; une EXPULSION est appliquée ici.
|
||||
*/
|
||||
public static boolean noterCritique(ServerPlayer p) {
|
||||
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID()) || estExempteManuellement(p.getUUID())) return false;
|
||||
List<Verdict> v = MOTEUR.critique(p.getUUID(), p.server.getTickCount() * 50L, etat(p, true));
|
||||
Sanction s = traiter(p, v);
|
||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||
return Cablage.sanctionDeMouvement(s);
|
||||
}
|
||||
public static void noterTickServeur(MinecraftServer server, long dureeNs) {
|
||||
double ms = dureeNs / 1_000_000.0;
|
||||
if (ms > 250.0) gelTick = server.getTickCount();
|
||||
@@ -872,7 +883,8 @@ 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.VOL) != Mode.OFF || CONFIG.mode(Controle.STEP) != Mode.OFF
|
||||
|| CONFIG.mode(Controle.CRITICALS) != Mode.OFF; // criticals : suit la hauteur à chaque mouvement
|
||||
}
|
||||
|
||||
/**
|
||||
|
||||
@@ -114,6 +114,16 @@ public final class GardeEvents {
|
||||
if (Cablage.appliquerApresCoup(s)) Garde.appliquerSanctionMouvement(p, s, verdicts);
|
||||
}
|
||||
|
||||
/** 0.5 (P1.10) : coup critique vanilla (Criticals) ; en ENFORCE au palier SETBACK, le critique est annulé. */
|
||||
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||
public static void onCritique(net.neoforged.neoforge.event.entity.player.CriticalHitEvent event) {
|
||||
if (!event.isVanillaCritical()) return;
|
||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
if (Garde.noterCritique(p)) {
|
||||
event.setCriticalHit(false);
|
||||
event.setDamageMultiplier(1.0F);
|
||||
}
|
||||
}
|
||||
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
|
||||
@SubscribeEvent
|
||||
public static void onRelache(LivingEntityUseItemEvent.Stop event) {
|
||||
|
||||
@@ -24,7 +24,8 @@ 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.DoubleValue STEP_HAUTEUR, STEP_MARGE, CRIT_MICRO;
|
||||
private static final ModConfigSpec.IntValue CRIT_SERIE;
|
||||
private static final ModConfigSpec.IntValue JOURNAL_LIMITE;
|
||||
|
||||
private static final ModConfigSpec.DoubleValue ANGLE_MAX;
|
||||
@@ -143,6 +144,11 @@ public final class GardeSpec {
|
||||
.defineInRange("pingLatenceMaxMs", 300, 0, 1000);
|
||||
VITESSE_CIBLE_MAX = b.comment("Cible plus rapide (blocs/tick) : portée et hitbox ne mesurent pas (élytres, recul, téléportation).")
|
||||
.defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
|
||||
CRIT_MICRO = b.comment("0.5 (P1.10) criticals : critique suspect si, depuis le dernier « au sol » du client, le joueur n'est ni monté",
|
||||
"ni descendu de plus de cette valeur (blocs). Vrai saut : ~1,25 ; micro-saut de cheat : 0,0625.")
|
||||
.defineInRange("criticalsMicroSautMax", 0.1, 0.01, 1.0);
|
||||
CRIT_SERIE = b.comment("Criticals : critiques suspects, parmi les 10 derniers en 60 s, avant qu'un critique suspect compte.")
|
||||
.defineInRange("criticalsSerieMin", 3, 1, 10);
|
||||
b.pop();
|
||||
|
||||
b.comment("Contrôle coups-hors-boite (#92) : le regard est testé contre toutes les positions où le client a pu",
|
||||
@@ -413,6 +419,8 @@ public final class GardeSpec {
|
||||
c.graceConnexionTicks = GRACE_CONNEXION.get();
|
||||
c.stepHauteurMax = STEP_HAUTEUR.get();
|
||||
c.stepMargeBlocs = STEP_MARGE.get();
|
||||
c.criticalsMicroSautMax = CRIT_MICRO.get();
|
||||
c.criticalsSerieMin = CRIT_SERIE.get();
|
||||
c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
|
||||
c.setbackSolSiPasDePosition = SETBACK_SOL.get();
|
||||
c.graceReculTicks = GRACE_RECUL.get();
|
||||
|
||||
@@ -25,7 +25,9 @@ public enum Controle {
|
||||
/** 0.4.0 : totem remis en main sans délai humain après l'éclatement (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");
|
||||
STEP("step"),
|
||||
/** 0.5 (P1.10) : coups critiques en série sans vrai saut ni vraie chute (Criticals, micro-sauts fictifs). */
|
||||
CRITICALS("criticals");
|
||||
|
||||
private final String id;
|
||||
|
||||
@@ -53,7 +55,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 -> 2;
|
||||
case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS -> 2;
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,78 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P1.10) : auto-criticals. Vanilla 1.21.1 (Player.attack, vérifié dans les sources NeoForge 21.1.234) donne un
|
||||
* coup critique si {@code fallDistance > 0}, onGround faux (drapeau du CLIENT), pas d'échelle, pas d'eau, pas
|
||||
* d'aveuglement, pas de véhicule, pas de sprint et barre d'attaque > 0,9. Le cheat envoie juste avant le coup un
|
||||
* ou deux paquets « en l'air » avec un micro-saut (+0,0625 puis retour, ou onGround toujours faux) : le serveur
|
||||
* compte une chute et accorde le critique sans vrai saut.
|
||||
*
|
||||
* Signal : au coup critique vanilla, depuis le dernier paquet où le client se disait au sol, le joueur n'est
|
||||
* jamais monté de plus de {@link GardeConfig#criticalsMicroSautMax} ni descendu de plus de cette valeur. Un vrai
|
||||
* saut monte d'environ 1,25 bloc ; une chute d'un rebord descend de plus de 0,1 dès le 2e tick. Un coup isolé ne
|
||||
* compte pas : seulement une série ({@link GardeConfig#criticalsSerieMin} sur les {@link #SERIE} derniers critiques
|
||||
* en {@link #FENETRE_MS}).
|
||||
*
|
||||
* Cas limite connu [À VÉRIFIER en jeu] : coup critique au tout premier tick de chute après avoir quitté un rebord
|
||||
* (descente de 0,078 seulement) : vu comme suspect, d'où la série.
|
||||
*/
|
||||
public final class Criticals {
|
||||
|
||||
static final int SERIE = 10;
|
||||
static final long FENETRE_MS = 60_000;
|
||||
/** Au-delà, la référence au sol est abandonnée (longue chute, plané) : pas suspect. */
|
||||
static final int PAQUETS_AIR_MAX = 40;
|
||||
|
||||
private boolean solConnu;
|
||||
private double hauteur, haut, bas;
|
||||
private int paquetsAir;
|
||||
|
||||
private final long[] instants = new long[SERIE];
|
||||
private final boolean[] suspects = new boolean[SERIE];
|
||||
private int n, prochain;
|
||||
private int dernierCompte;
|
||||
|
||||
/** Chaque mouvement accepté (avant les exemptions : on suit seulement la hauteur). */
|
||||
public void mouvement(EtatMouvement m) {
|
||||
if (m.milieuSpecial()) {
|
||||
solConnu = false; // eau, échelle : vanilla refuse le critique, et la hauteur n'a plus de sens
|
||||
return;
|
||||
}
|
||||
if (m.auSolClient()) {
|
||||
solConnu = true;
|
||||
hauteur = haut = bas = 0;
|
||||
paquetsAir = 0;
|
||||
} else if (solConnu) {
|
||||
hauteur += m.dy();
|
||||
haut = Math.max(haut, hauteur);
|
||||
bas = Math.min(bas, hauteur);
|
||||
if (++paquetsAir > PAQUETS_AIR_MAX) solConnu = false;
|
||||
}
|
||||
}
|
||||
|
||||
/** Le critique en cours ne vient d'aucun vrai saut ni d'une vraie chute ? */
|
||||
public boolean suspect(GardeConfig cfg) {
|
||||
double s = cfg.criticalsMicroSautMax;
|
||||
return solConnu && paquetsAir > 0 && haut < s && bas > -s;
|
||||
}
|
||||
|
||||
/** Un coup critique vanilla : points si suspect et en série. */
|
||||
public double coup(long nowMs, GardeConfig cfg) {
|
||||
boolean s = suspect(cfg);
|
||||
instants[prochain] = nowMs;
|
||||
suspects[prochain] = s;
|
||||
prochain = (prochain + 1) % SERIE;
|
||||
n = Math.min(SERIE, n + 1);
|
||||
int compte = 0;
|
||||
for (int i = 0; i < n; i++) if (suspects[i] && nowMs - instants[i] <= FENETRE_MS) compte++;
|
||||
dernierCompte = compte;
|
||||
return s && compte >= Math.max(1, cfg.criticalsSerieMin) ? 2.0 : 0;
|
||||
}
|
||||
|
||||
public int dernierCompte() {
|
||||
return dernierCompte;
|
||||
}
|
||||
|
||||
public double haut() { return haut; }
|
||||
public double bas() { return bas; }
|
||||
}
|
||||
@@ -172,6 +172,10 @@ public final class GardeConfig {
|
||||
public double stepHauteurMax = 0.6;
|
||||
/** Step : marge (blocs) au-dessus de la hauteur permise. */
|
||||
public double stepMargeBlocs = 0.1;
|
||||
/** Criticals : coup critique suspect si, depuis le dernier « au sol » du client, ni montée ni descente au-delà (blocs). */
|
||||
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;
|
||||
|
||||
// --- Exemptions ---
|
||||
public int graceTeleportTicks = 40;
|
||||
|
||||
@@ -381,9 +381,11 @@ public final class Moteur {
|
||||
boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF;
|
||||
boolean vol = cfg.mode(Controle.VOL) != Mode.OFF;
|
||||
boolean step = cfg.mode(Controle.STEP) != Mode.OFF;
|
||||
if (!noFall && !vitesse && !vol && !step) return List.of();
|
||||
boolean criticals = cfg.mode(Controle.CRITICALS) != Mode.OFF;
|
||||
if (!noFall && !vitesse && !vol && !step && !criticals) 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();
|
||||
@@ -560,6 +562,23 @@ public final class Moteur {
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P1.10) : coup critique vanilla accordé par le serveur (CriticalHitEvent). Suspect s'il ne vient d'aucun
|
||||
* vrai saut ni d'aucune vraie chute (voir {@link Criticals}). En ENFORCE, l'adaptateur annule le critique au palier
|
||||
* SETBACK ; l'expulsion s'applique comme pour les autres contrôles de combat.
|
||||
*/
|
||||
public List<Verdict> critique(UUID joueur, long nowMs, EtatJoueur etat) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.CRITICALS) == Mode.OFF) return List.of();
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
|
||||
if (ex.exempt()) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
double pts = s.criticals.coup(nowMs, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.CRITICALS, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"critique sans vrai saut (montee %.3f, descente %.3f), %d critiques suspects sur %d",
|
||||
s.criticals.haut(), -s.criticals.bas(), s.criticals.dernierCompte(), Criticals.SERIE));
|
||||
return v;
|
||||
}
|
||||
// --- Setback, expulsion, position de retour (16/10, incident VOL) ----------------------------------------
|
||||
|
||||
/**
|
||||
|
||||
@@ -61,6 +61,8 @@ public final class Suivi {
|
||||
public final AutoTotem totem = new AutoTotem();
|
||||
/** 0.5 (P1) : step. */
|
||||
public final Step step = new Step();
|
||||
/** 0.5 (P1.10) : criticals. */
|
||||
public final Criticals criticals = new Criticals();
|
||||
|
||||
public Suivi(double decroissanceParSeconde) {
|
||||
this(decroissanceParSeconde, new GardeConfig());
|
||||
|
||||
@@ -0,0 +1,117 @@
|
||||
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.10 : auto-criticals (micro-sauts fictifs avant le coup). */
|
||||
class CriticalsP1Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
private long t = 1000;
|
||||
|
||||
private static EtatMouvement paquet(double dy, boolean solClient) {
|
||||
return new EtatMouvement(0, dy, 1, solClient, solClient, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
private void bouger(Moteur m, EtatMouvement... suite) {
|
||||
for (EtatMouvement e : suite) {
|
||||
t += 50;
|
||||
m.mouvement(joueur, t, EtatJoueur.normal(), e);
|
||||
}
|
||||
}
|
||||
|
||||
private double critique(Moteur m) {
|
||||
return m.critique(joueur, t, EtatJoueur.normal()).stream()
|
||||
.filter(v -> v.controle() == Controle.CRITICALS).mapToDouble(Verdict::points).sum();
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefautEtFiabiliteFaible() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.CRITICALS));
|
||||
assertEquals(2, Controle.CRITICALS.fiabilite());
|
||||
}
|
||||
|
||||
@Test
|
||||
void microSautsAvantChaqueCoupVusEnSerie() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double total = 0;
|
||||
int premierCompte = -1;
|
||||
for (int i = 0; i < 6; i++) {
|
||||
// Wurst « packet » : +0,0625 puis retour au niveau du sol, onGround faux, puis le coup.
|
||||
bouger(m, paquet(0, true), paquet(0.0625, false), paquet(-0.0625, false));
|
||||
double p = critique(m);
|
||||
if (p > 0 && premierCompte < 0) premierCompte = i + 1;
|
||||
total += p;
|
||||
}
|
||||
assertTrue(total > 0);
|
||||
assertEquals(3, premierCompte, "rien avant le 3e critique suspect (criticalsSerieMin)");
|
||||
}
|
||||
|
||||
@Test
|
||||
void vraisSautsJamaisSuspects() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double total = 0;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
bouger(m, paquet(0, true), paquet(0.42, false), paquet(0.333, false), paquet(0.248, false),
|
||||
paquet(0.165, false), paquet(0.083, false), paquet(0.0, false), paquet(-0.078, false));
|
||||
total += critique(m);
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void chuteDUnRebordAuDeuxiemeTickPasSuspecte() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double total = 0;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
bouger(m, paquet(0, true), paquet(-0.078, false), paquet(-0.155, false));
|
||||
total += critique(m);
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void longueChuteOuMilieuSpecialAbandonneLaReference() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
bouger(m, paquet(0, true));
|
||||
for (int i = 0; i < Criticals.PAQUETS_AIR_MAX + 1; i++) bouger(m, paquet(0, false)); // flottement (vol couvre)
|
||||
Criticals c = m.suivi(joueur).criticals;
|
||||
assertTrue(!c.suspect(cfg));
|
||||
bouger(m, paquet(0, true), paquet(0.0625, false));
|
||||
assertTrue(c.suspect(cfg));
|
||||
t += 50;
|
||||
m.mouvement(joueur, t, EtatJoueur.normal(),
|
||||
new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, true, false));
|
||||
assertTrue(!c.suspect(cfg), "eau / échelle");
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptionCombatEtModeOff() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
for (int i = 0; i < 5; i++) {
|
||||
bouger(m, paquet(0, true), paquet(0.0625, false), paquet(-0.0625, false));
|
||||
List<Verdict> v = m.critique(joueur, t, EtatJoueur.builder().enVehicule(true).build());
|
||||
assertTrue(v.isEmpty(), "passager : exempté");
|
||||
}
|
||||
cfg.mode(Controle.CRITICALS, Mode.OFF);
|
||||
assertTrue(m.critique(joueur, t, EtatJoueur.normal()).isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
void enforceAtteintLeSetbackPourAnnulerLeCritique() {
|
||||
cfg.mode(Controle.CRITICALS, Mode.ENFORCE);
|
||||
Moteur m = new Moteur(cfg);
|
||||
Sanction pire = Sanction.AUCUNE;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
bouger(m, paquet(0, true), paquet(0.0625, false), paquet(-0.0625, false));
|
||||
Sanction s = Verdict.pire(m.critique(joueur, t, EtatJoueur.normal()));
|
||||
if (s.ordinal() > pire.ordinal()) pire = s;
|
||||
}
|
||||
assertTrue(pire.ordinal() >= Sanction.SETBACK.ordinal(), "" + pire);
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur