F11 (suite) : regard de reference par tick serveur, une inondation de paquets ne le chasse plus

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:19:24 +02:00
1 Parent ec17ccae5d
révision 6329cd3d63
3 fichiers modifiés
+46 -13

Aucun fichier ne correspond à votre recherche

+2 -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_*` (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`).
+27 -12
Voir le fichier
@@ -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).
*
* <p>Coût constant : 8 derniers regards.
* <p>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;
}
}
+17
Voir le fichier
@@ -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");
}
}