From 41969835ef7e561f9b0acf18a279a2b7fd0d3c12 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Wed, 14 Oct 2026 09:07:59 +0200 Subject: [PATCH] F12 : cadence comptee par tranches de 50 ms, plafond de 3 coups par tick Co-Authored-By: Claude Opus 5.5 --- audit/CORRECTIONS.md | 6 +++- .../java/com/gastinelgarde/core/Cadence.java | 23 ++++++++++-- .../gastinelgarde/core/AuditFaillesTest.java | 36 +++++++++++++++++++ .../com/gastinelgarde/core/ControlesTest.java | 3 +- 4 files changed, 63 insertions(+), 5 deletions(-) diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index ad0657b..d448d2c 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -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). diff --git a/src/main/java/com/gastinelgarde/core/Cadence.java b/src/main/java/com/gastinelgarde/core/Cadence.java index a588bb0..fab519a 100644 --- a/src/main/java/com/gastinelgarde/core/Cadence.java +++ b/src/main/java/com/gastinelgarde/core/Cadence.java @@ -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. + * + *

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(); } } diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index 9b90048..5cc5727 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -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"); + } } diff --git a/src/test/java/com/gastinelgarde/core/ControlesTest.java b/src/test/java/com/gastinelgarde/core/ControlesTest.java index 421bab2..f5bfe5c 100644 --- a/src/test/java/com/gastinelgarde/core/ControlesTest.java +++ b/src/test/java/com/gastinelgarde/core/ControlesTest.java @@ -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