F12 : cadence comptee par tranches de 50 ms, plafond de 3 coups par tick

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:07:59 +02:00
1 Parent d8ade0be1f
révision 41969835ef
4 fichiers modifiés
+63 -5

Aucun fichier ne correspond à votre recherche

+5 -1
Voir le fichier
@@ -15,7 +15,7 @@ Base avant corrections : 98 tests verts.
| F07 ping | corrigée | `git log --grep F07` | `AuditFaillesTest.F07_*`, `ExemptionsTest.lagAugmenteLaTolerance` (assertion inversée) ; 110 verts | essai en jeu n° 3 ; mesurer dans les traces si un joueur honnête en wifi médiocre lève des fausses alertes |
| F08 vol aveugle | corrigée | `git log --grep F08` | `AuditFaillesTest.F08_*` (2), `MouvementTest` (ancien test de l'angle mort inversé, +1) ; 113 verts | essai en jeu n° 12 ; vérifier dans les traces qu'une chute honnête avec lag ne lève pas `vol` |
| F02 timer inondation | corrigée | `git log --grep F02` | `AuditFaillesTest.F02_*` (2) ; 116 verts | rien (F03, balance de timer, reste une évolution) |
| F12 cadence saturée | à faire | | | |
| 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 | à faire | | | |
| F20 véhicules | à faire | | | |
| F11 rotation silencieuse | à faire | | | |
@@ -59,3 +59,7 @@ Base avant corrections : 98 tests verts.
### F02
- Nouveau `core/CompteurTranches` : nombre d'événements par tranche de 50 ms, historique fixe (601 tranches, 30 s, environ 7 Ko par joueur). Une rafale ne chasse plus l'historique. `TimerPaquets` compte les secondes glissantes par 20 tranches (fenêtre réelle de 1000 à 1049 ms au lieu de 1000 ms exactement). Mêmes seuils, tests existants verts.
- F03 (timer 1,05-1,10x, blink) non traité : c'est la balance de timer de la synthèse (nouveau contrôle).
### F12
- `Cadence` compte les coups par tranches de 50 ms (`CompteurTranches(50, 41)`) : 200 coups/s sont vus comme 40 coups/s. La fenêtre circulaire ne sert plus qu'à la régularité (derniers intervalles).
- Plafond par tick : plus de 3 coups dans **deux** ticks consécutifs = infraction immédiate. Une rafale isolée (paquets retenus par le lag, puis délivrés dans un seul tick) ne compte pas. Seuil 3 en dur [À VÉRIFIER] avec les traces (clics papillon à bas FPS).
+20 -3
Voir le fichier
@@ -4,6 +4,10 @@ package com.gastinelgarde.core;
* Contrôles 3 : cadence des coups (plus de {@code cpsMax} par seconde pendant deux secondes) et régularité
* suspecte des intervalles (écart type très bas à cadence rapide). Les temps sont ceux du serveur en ms
* (tick × 50) : un client honnête est donc quantifié au tick, d'où un seuil d'écart type volontairement bas.
*
* <p>F12 : la cadence se compte par tranches de 50 ms ({@link CompteurTranches}) et non plus sur les 128 derniers
* coups, qu'un client à plus de 128 coups/s chassait de la fenêtre. Plafond par tick en plus : plus de
* {@link #COUPS_PAR_TICK_MAX} coups dans deux ticks consécutifs (une rafale isolée peut venir du lag, deux non).
*/
public final class Cadence {
@@ -11,18 +15,30 @@ public final class Cadence {
public static final Resultat RIEN = new Resultat(0, 0);
}
private final Fenetre fenetre = new Fenetre(128);
/** Coups au-delà desquels un tick est anormal (vanilla : un clic humain par tick au plus, lag compris : 3). */
static final int COUPS_PAR_TICK_MAX = 3;
/** Intervalles pour la régularité : les derniers coups suffisent (au plus 128 échantillons en configuration). */
private final Fenetre fenetre = new Fenetre(129);
/** 40 tranches de 50 ms (deux secondes) plus la tranche courante. */
private final CompteurTranches tranches = new CompteurTranches(50, 41);
public Resultat enregistrer(long nowMs, GardeConfig cfg, double facteur) {
fenetre.ajouter(nowMs, 0);
tranches.ajouter(nowMs);
double points = 0;
int cps = (int) Math.floor(cfg.cpsMax * facteur);
int dernierSecond = fenetre.compter(nowMs - 999, nowMs + 1);
int precedent = fenetre.compter(nowMs - 1999, nowMs - 999);
int dernierSecond = tranches.compter(nowMs, 0, 20);
int precedent = tranches.compter(nowMs, 20, 20);
if (dernierSecond > cps && precedent > cps) {
points = 1.0 + Math.min(3.0, (dernierSecond - cps) / 5.0);
}
int ceTick = tranches.compter(nowMs, 0, 1);
int tickAvant = tranches.compter(nowMs, 1, 1);
if (ceTick > COUPS_PAR_TICK_MAX && tickAvant > COUPS_PAR_TICK_MAX) {
points = Math.max(points, 1.0 + Math.min(3.0, (ceTick - COUPS_PAR_TICK_MAX) / 2.0));
}
double regularite = 0;
int echantillons = cfg.echantillonsRegularite;
@@ -49,5 +65,6 @@ public final class Cadence {
public void vider() {
fenetre.vider();
tranches.vider();
}
}
+36
Voir le fichier
@@ -278,4 +278,40 @@ class AuditFaillesTest {
GraceRecul autre = new GraceRecul();
for (int tick = 0; tick < 100; tick += 10) assertTrue(autre.recul(tick, false), "recul subi : toujours une grâce");
}
// ---------------------------------------------------------------- F12
/** Au-delà de 128 coups/s, l'ancienne fenêtre ne contenait plus « la seconde précédente » : cadence muette. */
@Test
void F12_cadence_saturation_vue() {
UUID spam = UUID.randomUUID();
UUID rapide = UUID.randomUUID();
boolean vuSpam = false, vuRapide = false;
for (int tick = 0; tick < 100; tick++) {
for (int k = 0; k < 10; k++) { // 10 coups par tick = 200/s
if (contient(moteur.attaque(spam, tick * 50L, EtatJoueur.normal(), 0, 7, true), Controle.CADENCE)) vuSpam = true;
}
for (int k = 0; k < 2; k++) { // 2 coups par tick = 40/s
if (contient(moteur.attaque(rapide, tick * 50L, EtatJoueur.normal(), 0, 7, true), Controle.CADENCE)) vuRapide = true;
}
}
assertTrue(vuRapide, "40 coups/s : vu (témoin)");
assertTrue(vuSpam, "200 coups/s : vu");
}
/** Plafond par tick : plus de 3 coups dans deux ticks consécutifs est vu tout de suite ; une rafale de lag isolée non. */
@Test
void F12_plafond_par_tick() {
Cadence c = new Cadence();
double max = 0;
for (int k = 0; k < 5; k++) max = Math.max(max, c.enregistrer(0, cfg, 1.0).cadence());
assertEquals(0, max, 1e-9, "une rafale isolée (paquets retenus par le lag) : rien");
for (int k = 0; k < 5; k++) max = Math.max(max, c.enregistrer(50, cfg, 1.0).cadence());
assertTrue(max > 0, "5 coups dans deux ticks de suite : vu immédiatement");
Cadence lag = new Cadence();
double maxLag = 0;
for (int k = 0; k < 10; k++) maxLag = Math.max(maxLag, lag.enregistrer(1000, cfg, 1.0).cadence());
for (long t = 1050; t < 3000; t += 100) maxLag = Math.max(maxLag, lag.enregistrer(t, cfg, 1.0).cadence());
assertEquals(0, maxLag, 1e-9, "10 coups retenus puis 10 coups/s : rien");
}
}
+2 -1
Voir le fichier
@@ -122,7 +122,8 @@ class ControlesTest {
dernier = p;
}
assertEquals(0, premier, 1e-9);
assertEquals(2.0, dernier, 1e-9);
// F12 : seconde comptée par tranches de 50 ms (1050-2049 ms ici : 24 coups au lieu de 25 à 40 ms d'écart).
assertEquals(1.8, dernier, 1e-9);
}
@Test