diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index 72e0a66..5f6c06c 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_*` (5) ; `MixinsAppliquesTest` couvre la nouvelle injection ; 126 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 | 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` | +| F11 rotation silencieuse | corrigée (seuils [À VÉRIFIER]) | `git log --grep F11` | `AuditFaillesTest.F11_*` (3) ; 127 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 | | | | @@ -80,3 +80,4 @@ Base avant corrections : 98 tests verts. - 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). - Suite (revue de sécurité du commit F20) : (1) la distance permise se compte en ticks serveur écoulés : un solde (crédit plafonné à 2 ticks, dette au-delà de 1,5 bloc = infraction) remplace le tampon par paquet ; dix paquets dans un tick ne valent plus dix fois la distance (`F20_paquets_multiples_dans_un_tick_vus`, gigue honnête incluse). (2) Sur la glace, borne du type (bateau 4,0 ; monture ×2) au lieu de l'infini, élan plafonné à 4,0 (`F20_elan_de_glace_borne`). (3) En véhicule, la position de retour n'est mémorisée qu'après un paquet de véhicule sans verdict. (4) Changer de véhicule ou remonter ne remet le temps en l'air et le solde à zéro qu'après 2 s sans véhicule. +- F11 suite (revue de sécurité du commit F11) : le regard de référence est le regard de fin de tick des 4 derniers ticks serveur, et non plus des 8 derniers paquets : une inondation de paquets de rotation ne le chasse plus (`F11_inondation_de_rotations_vue`). diff --git a/src/main/java/com/gastinelgarde/core/RotationSilencieuse.java b/src/main/java/com/gastinelgarde/core/RotationSilencieuse.java index 65a6d02..1de7c38 100644 --- a/src/main/java/com/gastinelgarde/core/RotationSilencieuse.java +++ b/src/main/java/com/gastinelgarde/core/RotationSilencieuse.java @@ -11,21 +11,28 @@ package com.gastinelgarde.core; * 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. + *
Coût constant : le dernier regard reçu et le regard de fin des 4 derniers ticks serveur. L'historique avance + * par tick serveur, pas par paquet (revue de sécurité de F11 : huit paquets de rotation en deux ticks chassaient + * le regard de référence d'un historique par paquet). */ 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 static final int HISTORIQUE = 4; + /** Regard de fin de tick des derniers ticks serveur où un regard a été reçu. */ 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 aRegard; + private long tickCourant; + private float yawCourant, pitchCourant; + private boolean enAttente; private float avantYaw, avantPitch, coupYaw, coupPitch; private long limite; @@ -36,11 +43,18 @@ public final class RotationSilencieuse { * @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 (aRegard && tick > tickCourant) { + // Nouveau tick : le dernier regard du tick précédent devient son regard de fin. + ticks[tete] = tickCourant; + yaws[tete] = yawCourant; + pitchs[tete] = pitchCourant; + tete = (tete + 1) % HISTORIQUE; + if (taille < HISTORIQUE) taille++; + } + aRegard = true; + tickCourant = Math.max(tickCourant, tick); + yawCourant = yaw; + pitchCourant = pitch; if (!enAttente) return 0; if (tick > limite) { @@ -57,8 +71,7 @@ public final class RotationSilencieuse { /** 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); + if (!aRegard || taille == 0) return; int reference = -1; for (int k = 1; k <= taille; k++) { int i = Math.floorMod(tete - k, HISTORIQUE); @@ -68,12 +81,12 @@ public final class RotationSilencieuse { } } if (reference < 0) return; - if (angle(yaws[reference], pitchs[reference], yaws[dernier], pitchs[dernier]) < SNAP_DEGRES) return; + if (angle(yaws[reference], pitchs[reference], yawCourant, pitchCourant) < SNAP_DEGRES) return; enAttente = true; avantYaw = yaws[reference]; avantPitch = pitchs[reference]; - coupYaw = yaws[dernier]; - coupPitch = pitchs[dernier]; + coupYaw = yawCourant; + coupPitch = pitchCourant; limite = tick + DELAI_TICKS; } @@ -90,6 +103,8 @@ public final class RotationSilencieuse { public void vider() { taille = 0; tete = 0; + aRegard = false; + tickCourant = 0; enAttente = false; } } diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index 6b4b6c0..20dc7a6 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -487,4 +487,21 @@ class AuditFaillesTest { } assertTrue(vu, "bateau à 8 blocs/tick sur la glace : vu"); } + + /** Revue de sécurité de F11 : dix paquets de rotation par tick avant le coup ne chassent plus le regard de référence. */ + @Test + void F11_inondation_de_rotations_vue() { + boolean vu = false; + for (int tick = 0; tick < 200; tick++) { + long now = tick * 50L; + int phase = tick % 7; + if (phase == 2 || phase == 3) { + for (int k = 0; k < 10; k++) vu |= contient(moteur.regard(j, now, EtatJoueur::normal, 90f, 0f), Controle.ROTATION); + if (phase == 3) moteur.attaque(j, now, EtatJoueur.normal(), 0.0, 100 + tick % 3, true); + } else { + vu |= contient(moteur.regard(j, now, EtatJoueur::normal, 0f, 0f), Controle.ROTATION); + } + } + assertTrue(vu, "rotation vers la cible sur deux ticks inondés de paquets, coup, retour : vu"); + } }