F11 : controle rotation, aller-retour du regard autour d'un coup (rotation silencieuse)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Opus 5.5 a révisé 2026-10-14 09:16:22 +02:00
1 Parent 16a9bd6ee0
révision e2322fbdf4
7 fichiers modifiés
+165 -1

Aucun fichier ne correspond à votre recherche

+6 -1
Voir le fichier
@@ -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).
+5
Voir le fichier
@@ -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<Verdict> 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();
+1
Voir le fichier
@@ -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"),
+18
Voir le fichier
@@ -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<Verdict> regard(UUID joueur, long nowMs, java.util.function.Supplier<EtatJoueur> 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<Verdict> 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). */
+95
Voir le fichier
@@ -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.
*
* <p>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).
*
* <p>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;
}
}
+1
Voir le fichier
@@ -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();
+39
Voir le fichier
@@ -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<Verdict> 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");
}
}