diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index a59c564..c853e12 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -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 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 } /** diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index 23661ed..49f2827 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -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) { diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index a127476..aca4a38 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -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(); diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index 00a4af1..19c0d2d 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -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; }; } diff --git a/src/main/java/com/gastinelgarde/core/Criticals.java b/src/main/java/com/gastinelgarde/core/Criticals.java new file mode 100644 index 0000000..93e8fcf --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/Criticals.java @@ -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; } +} diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index 41ce451..4e99143 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -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; diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index 2745c74..b6327db 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -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 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 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) ---------------------------------------- /** diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index 9c5fd83..7898861 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -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()); diff --git a/src/test/java/com/gastinelgarde/core/CriticalsP1Test.java b/src/test/java/com/gastinelgarde/core/CriticalsP1Test.java new file mode 100644 index 0000000..0498303 --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/CriticalsP1Test.java @@ -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 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); + } +}