From e2322fbdf487e20401fe4935a2bf464998c26ee5 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Wed, 14 Oct 2026 09:16:22 +0200 Subject: [PATCH] F11 : controle rotation, aller-retour du regard autour d'un coup (rotation silencieuse) Co-Authored-By: Claude Opus 5.5 --- audit/CORRECTIONS.md | 7 +- src/main/java/com/gastinelgarde/Garde.java | 5 + .../java/com/gastinelgarde/core/Controle.java | 1 + .../java/com/gastinelgarde/core/Moteur.java | 18 ++++ .../core/RotationSilencieuse.java | 95 +++++++++++++++++++ .../java/com/gastinelgarde/core/Suivi.java | 1 + .../gastinelgarde/core/AuditFaillesTest.java | 39 ++++++++ 7 files changed, 165 insertions(+), 1 deletion(-) create mode 100644 src/main/java/com/gastinelgarde/core/RotationSilencieuse.java diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index 566da0b..60f980e 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -18,7 +18,7 @@ Base avant corrections : 98 tests verts. | F12 cadence saturée | corrigée | `git log --grep F12` | `AuditFaillesTest.F12_*` (2), `ControlesTest.cadenceFolleSoutenue` (1,8 au lieu de 2,0 : bord de tranche) ; 118 verts | essai en jeu n° 10 (combat honnête contre plusieurs zombies, aucune ligne `cadence`) | | F13 cibles saturées | corrigée | `git log --grep F13` | `AuditFaillesTest.F13_*` (rouge avant) ; 119 verts | essai en jeu n° 10 | | F20 véhicules | corrigée (bornes [À VÉRIFIER]) | `git log --grep F20` | `AuditFaillesTest.F20_*` (3) ; `MixinsAppliquesTest` couvre la nouvelle injection ; 122 verts | essai en jeu n° 14 + bateau sur glace bleue, cheval rapide, chameau (dash), cochon, arpenteur : aucune fausse alerte ; rejeu des lignes `veh` non écrit | -| F11 rotation silencieuse | à faire | | | | +| F11 rotation silencieuse | corrigée (seuils [À VÉRIFIER]) | `git log --grep F11` | `AuditFaillesTest.F11_*` (2) ; 124 verts | essai en jeu n° 11 ; PvP honnête rapide sans ligne `rotation` | | F19, F22, F25 | essais en jeu seulement | | | `audit/ESSAIS-EN-JEU.md` | | Version 0.3.0, jar, README, script | à faire | | | | @@ -74,3 +74,8 @@ Base avant corrections : 98 tests verts. - Vol : en l'air (ni sol, ni fluide, ni colonne à bulles, ni échelle, ni lévitation/chute lente de la monture) plus de 40 ticks sans tomber d'au moins 0,2 bloc/tick. Vanilla : un bateau en l'air prend −0,04/tick sans frein vertical, un saut de cheval dure ~25 ticks. - ENFORCE : un setback fait d'abord descendre le joueur (`stopRiding`) puis le ramène à sa dernière position valide. - [À VÉRIFIER] : chameau (dash), cochon/arpenteur boostés, courant d'eau, bateau poussé par une entité ; vitesse des montures de mods. Le rejeu (`Rejeu`) ignore encore les lignes de trace `veh`. + +### F11 +- Nouveau contrôle `rotation` (OBSERVE, famille d'exemptions COMBAT) : `core/RotationSilencieuse`. Au coup, si le regard s'est écarté d'au moins 45° du regard de la fin du tick t-2, on attend : si dans les 3 ticks il revient à moins de 15° du regard d'avant, c'est un aller-retour (1 point). Les regards viennent de chaque paquet de mouvement accepté (`Garde.apresMouvement` → `Moteur.regard`). +- Le coup a déjà eu lieu quand l'aller-retour est vu : journal et VL seulement, aucune sanction directe. +- Non fait (audit) : vitesse de rotation avant le coup, deux cibles espacées de plus de 90° en moins de 3 ticks ; une killaura qui revient lentement (plus de 3 ticks) ou ne revient pas passe encore. Reach jamais mesuré (contrôle à ajouter, synthèse n° 3). diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 43fe3f6..bcdc77a 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -438,6 +438,11 @@ public final class Garde { Sanction s = traiter(p, v); if (s.ordinal() >= Sanction.SETBACK.ordinal()) appliquerSanctionMouvement(p, s, v); } + // F11 : regard accepté, pour repérer l'aller-retour d'une rotation silencieuse autour d'un coup. + if (!estExempteManuellement(p.getUUID())) { + List v = MOTEUR.regard(p.getUUID(), tick * 50L, () -> etat(p, true), p.getYRot(), p.getXRot()); + traiter(p, v); // le coup a déjà eu lieu : journal et VL seulement + } m.mouvementTick = tick; m.mouvementX = p.getX(); m.mouvementY = p.getY(); diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index a60725c..08b2830 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -7,6 +7,7 @@ public enum Controle { CADENCE("cadence"), REGULARITE("regularite"), ATTAQUE_IMPOSSIBLE("attaque-impossible"), + ROTATION("rotation"), TIMER("timer"), NO_FALL("no-fall"), VITESSE("vitesse"), diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index b364e55..aecb3de 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -77,6 +77,7 @@ public final class Moteur { if (cadenceActive) ajouter(verdicts, s, Controle.CADENCE, r.cadence(), nowMs, ex, "coups par seconde trop eleves"); if (regulariteActive) ajouter(verdicts, s, Controle.REGULARITE, r.regularite(), nowMs, ex, "intervalles trop reguliers"); } + if (cfg.mode(Controle.ROTATION) != Mode.OFF) s.rotation.coup(nowMs / 50); if (cfg.mode(Controle.ATTAQUE_IMPOSSIBLE) != Mode.OFF) { double pts = AttaqueImpossible.points(etat.utiliseObjet(), !cibleVisible); ajouter(verdicts, s, Controle.ATTAQUE_IMPOSSIBLE, pts, nowMs, ex, @@ -85,6 +86,23 @@ public final class Moteur { return verdicts; } + /** + * Un regard accepté (paquet de mouvement) : termine éventuellement un aller-retour de rotation autour d'un + * coup (F11). L'état du joueur n'est construit que si un aller-retour est vu. + */ + public List regard(UUID joueur, long nowMs, java.util.function.Supplier etat, + float yaw, float pitch) { + if (cfg.mode(Controle.ROTATION) == Mode.OFF) return List.of(); + Suivi s = suivi(joueur); + double pts = s.rotation.regard(nowMs / 50, yaw, pitch); + if (pts <= 0) return List.of(); + Exemptions.Resultat ex = Exemptions.evaluer(etat.get(), cfg, Exemptions.Famille.COMBAT); + if (ex.exempt()) return List.of(); + List verdicts = new ArrayList<>(1); + ajouter(verdicts, s, Controle.ROTATION, pts, nowMs, ex, "regard aller-retour autour d'un coup"); + return verdicts; + } + // --- Mouvement -------------------------------------------------------------------------------------- /** Un paquet de mouvement vient d'arriver (temps réel en ms, pour mesurer le débit). */ diff --git a/src/main/java/com/gastinelgarde/core/RotationSilencieuse.java b/src/main/java/com/gastinelgarde/core/RotationSilencieuse.java new file mode 100644 index 0000000..65a6d02 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/RotationSilencieuse.java @@ -0,0 +1,95 @@ +package com.gastinelgarde.core; + +/** + * Contrôle de rotation (F11) : killaura à rotation « silencieuse » (ou « côté serveur »). Le client envoie un + * paquet de rotation vers la cible juste avant le coup, puis revient à son regard au paquet suivant : au moment du + * coup, le regard serveur est parfait et {@link KillauraAngle} ne voit rien. + * + *

On repère l'aller-retour : au coup, le regard s'est écarté d'au moins {@link #SNAP_DEGRES} du regard d'avant + * (fin du tick t-2, pour couvrir un paquet de rotation envoyé au tick précédent) ; puis, dans les + * {@link #DELAI_TICKS} ticks, il revient à moins de {@link #RETOUR_DEGRES} de ce regard d'avant. Un joueur + * honnête qui se tourne vers sa cible continue de la regarder, ou repart ailleurs, mais revient rarement pile + * en arrière en un ou deux ticks. Seuils à régler avec les traces [À VÉRIFIER] (combat PvP rapide). + * + *

Coût constant : 8 derniers regards. + */ +public final class RotationSilencieuse { + + public static final double SNAP_DEGRES = 45.0; + public static final double RETOUR_DEGRES = 15.0; + public static final int DELAI_TICKS = 3; + private static final int HISTORIQUE = 8; + + private final long[] ticks = new long[HISTORIQUE]; + private final float[] yaws = new float[HISTORIQUE]; + private final float[] pitchs = new float[HISTORIQUE]; + private int taille; + private int tete; // prochaine case écrite + + private boolean enAttente; + private float avantYaw, avantPitch, coupYaw, coupPitch; + private long limite; + + /** + * Un regard accepté par le serveur (un paquet de mouvement). + * + * @return points (1 si un aller-retour autour d'un coup vient de se terminer, 0 sinon) + */ + public double regard(long tick, float yaw, float pitch) { + ticks[tete] = tick; + yaws[tete] = yaw; + pitchs[tete] = pitch; + tete = (tete + 1) % HISTORIQUE; + if (taille < HISTORIQUE) taille++; + + if (!enAttente) return 0; + if (tick > limite) { + enAttente = false; + return 0; + } + if (angle(avantYaw, avantPitch, yaw, pitch) <= RETOUR_DEGRES + && angle(coupYaw, coupPitch, yaw, pitch) >= SNAP_DEGRES - RETOUR_DEGRES) { + enAttente = false; + return 1.0; + } + return 0; + } + + /** Un coup est porté au tick donné, avec le dernier regard reçu. */ + public void coup(long tick) { + if (taille == 0) return; + int dernier = Math.floorMod(tete - 1, HISTORIQUE); + int reference = -1; + for (int k = 1; k <= taille; k++) { + int i = Math.floorMod(tete - k, HISTORIQUE); + if (ticks[i] <= tick - 2) { + reference = i; + break; + } + } + if (reference < 0) return; + if (angle(yaws[reference], pitchs[reference], yaws[dernier], pitchs[dernier]) < SNAP_DEGRES) return; + enAttente = true; + avantYaw = yaws[reference]; + avantPitch = pitchs[reference]; + coupYaw = yaws[dernier]; + coupPitch = pitchs[dernier]; + limite = tick + DELAI_TICKS; + } + + /** Angle en degrés entre deux regards (lacet et tangage Minecraft, en degrés). */ + public static double angle(float yaw1, float pitch1, float yaw2, float pitch2) { + double y1 = Math.toRadians(yaw1), p1 = Math.toRadians(pitch1); + double y2 = Math.toRadians(yaw2), p2 = Math.toRadians(pitch2); + double x1 = -Math.sin(y1) * Math.cos(p1), h1 = -Math.sin(p1), z1 = Math.cos(y1) * Math.cos(p1); + double x2 = -Math.sin(y2) * Math.cos(p2), h2 = -Math.sin(p2), z2 = Math.cos(y2) * Math.cos(p2); + double cos = Math.max(-1.0, Math.min(1.0, x1 * x2 + h1 * h2 + z1 * z2)); + return Math.toDegrees(Math.acos(cos)); + } + + public void vider() { + taille = 0; + tete = 0; + enAttente = false; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index dcffc8e..586d03e 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -9,6 +9,7 @@ public final class Suivi { public final VlCompteur vl; public final CiblesMultiples cibles = new CiblesMultiples(); public final Cadence cadence = new Cadence(); + public final RotationSilencieuse rotation = new RotationSilencieuse(); public final TimerPaquets timer = new TimerPaquets(); public final VitesseHorizontale vitesse = new VitesseHorizontale(); public final VolVertical vol = new VolVertical(); diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index 2ef076d..3f76014 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -415,4 +415,43 @@ class AuditFaillesTest { } assertFalse(vuCheval, "cheval honnête : rien"); } + + // ---------------------------------------------------------------- F11 + /** + * Killaura à rotation silencieuse : avant chaque coup, un paquet de rotation vers la cible (90° à côté du + * regard), le coup, puis le regard revient au tick suivant. L'excédent d'angle au coup est 0 : seul le + * contrôle de rotation le voit. + */ + @Test + void F11_rotation_silencieuse_vue() { + boolean vu = false, vuAngle = false; + for (int tick = 0; tick < 200; tick++) { + long now = tick * 50L; + if (tick % 7 == 3) { + vu |= contient(moteur.regard(j, now, EtatJoueur::normal, 90f, 0f), Controle.ROTATION); + List v = moteur.attaque(j, now, EtatJoueur.normal(), 0.0, 100 + tick % 3, true); + vuAngle |= contient(v, Controle.KILLAURA_ANGLE); + } else { + vu |= contient(moteur.regard(j, now, EtatJoueur::normal, 0f, 0f), Controle.ROTATION); + } + } + assertFalse(vuAngle, "regard parfait au moment du coup : killaura-angle ne voit rien (rappel de F11)"); + assertTrue(vu, "aller-retour du regard autour de chaque coup : vu"); + } + + /** Joueurs honnêtes : virage rapide vers une cible puis on la suit ; tour complet en frappant ; regard fixe. */ + @Test + void F11_rotations_honnetes_sans_alerte() { + boolean vu = false; + float yaw = 0; + for (int tick = 0; tick < 400; tick++) { + long now = tick * 50L; + int phase = tick % 40; + if (phase < 3) yaw += 40f; // virage de 120° en 3 ticks vers une nouvelle cible + else if (phase >= 20 && phase < 30) yaw += 36f; // tour complet en 10 ticks + vu |= !moteur.regard(j, now, EtatJoueur::normal, yaw, 10f).isEmpty(); + if (phase == 3 || phase == 6 || phase == 25) vu |= !moteur.attaque(j, now, EtatJoueur.normal(), 0, 5, true).isEmpty(); + } + assertFalse(vu, "rotations honnêtes : rien"); + } }