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 à :
1 Parent
16a9bd6ee0
révision
e2322fbdf4
7 fichiers modifiés
+165
-1
Aucun fichier ne correspond à votre recherche
@@ -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).
|
||||
@@ -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();
|
||||
|
||||
@@ -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"),
|
||||
|
||||
@@ -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). */
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
|
||||
@@ -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");
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur