F02 : timer par compteurs de tranches, une inondation de paquets ne l'aveugle 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 08:41:27 +02:00
1 Parent da9b42c075
révision d8ade0be1f
4 fichiers modifiés
+111 -7

Aucun fichier ne correspond à votre recherche

+5 -1
Voir le fichier
@@ -14,7 +14,7 @@ Base avant corrections : 98 tests verts.
| F06 grâce dégâts | corrigée | `git log --grep F06` | `AuditFaillesTest.F06_*`, `AdaptateursTest.F06_*` ; 109 verts | essai en jeu : Wind Charge, explosion, coup d'épée : aucune fausse alerte |
| 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 | à faire | | | |
| 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 | | | |
| F13 cibles saturées | à faire | | | |
| F20 véhicules | à faire | | | |
@@ -55,3 +55,7 @@ Base avant corrections : 98 tests verts.
- `VolVertical` : la prédiction `vy' = (vy − 0,08) × 0,98` est itérée sur les ticks écoulés (jusqu'à 40 ; au-delà, lag : on oublie la vitesse comme avant). Jitter toléré : un paquet en retard de n ticks peut couvrir n−1 ou n ticks ; un paquet à 0 tick (deuxième du même tick) en couvre 1. Tolérance 0,05 × ticks.
- Couvre aussi le joueur immobile en l'air qui n'envoie plus que le rappel de position toutes les 20 ticks.
- L'ancien test `paquetsManquantsNeFontPasDInfraction` affirmait l'angle mort : inversé en `paquetsEspacesEnVolStationnaireSontVus`.
### 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).
+63
Voir le fichier
@@ -0,0 +1,63 @@
package com.gastinelgarde.core;
/**
* Nombre d'événements par tranche de temps fixe (F02, F12). Contrairement à {@link Fenetre}, qui garde les N
* derniers événements, aucune rafale ne peut chasser l'historique : 1000 événements dans une tranche y sont
* comptés 1000 fois, et les tranches précédentes restent intactes. Coût mémoire constant (décision D4).
*/
public final class CompteurTranches {
private final long trancheMs;
private final long[] index;
private final int[] compte;
/**
* @param trancheMs durée d'une tranche
* @param nbTranches historique conservé (au moins la durée la plus longue interrogée, plus une tranche)
*/
public CompteurTranches(long trancheMs, int nbTranches) {
if (trancheMs <= 0 || nbTranches <= 0) throw new IllegalArgumentException("tranche et nombre > 0");
this.trancheMs = trancheMs;
this.index = new long[nbTranches];
this.compte = new int[nbTranches];
vider();
}
public long trancheMs() {
return trancheMs;
}
public int capacite() {
return index.length;
}
public void ajouter(long tempsMs) {
long t = Math.floorDiv(tempsMs, trancheMs);
int i = (int) Math.floorMod(t, (long) index.length);
if (index[i] != t) {
index[i] = t;
compte[i] = 0;
}
if (compte[i] < Integer.MAX_VALUE) compte[i]++;
}
/**
* Événements des {@code nb} tranches qui finissent {@code decalage} tranches avant celle de {@code tempsMs}
* (decalage 0 : la tranche courante incluse).
*/
public int compter(long tempsMs, int decalage, int nb) {
long fin = Math.floorDiv(tempsMs, trancheMs) - decalage;
long debut = fin - nb + 1;
int n = 0;
for (int i = 0; i < index.length; i++) {
long t = index[i];
if (t >= debut && t <= fin) n += compte[i];
}
return n;
}
public void vider() {
java.util.Arrays.fill(index, Long.MIN_VALUE);
java.util.Arrays.fill(compte, 0);
}
}
+13 -6
Voir le fichier
@@ -3,19 +3,26 @@ package com.gastinelgarde.core;
/**
* Contrôle 5 : trop de paquets de mouvement par seconde, soutenu plusieurs secondes (le jeu en envoie 20).
* Les horodatages sont en ms réelles : c'est le débit d'arrivée qu'on mesure.
*
* F02 : compteurs par tranche de 50 ms au lieu des 512 derniers paquets. Avant, au-delà d'environ 512 paquets/s,
* la fenêtre ne couvrait plus les secondes précédentes et le contrôle ne voyait plus rien.
*/
public final class TimerPaquets {
private final Fenetre fenetre = new Fenetre(512);
private static final long TRANCHE_MS = 50;
private static final int TRANCHES_PAR_SECONDE = (int) (1000 / TRANCHE_MS);
/** Au plus 30 secondes soutenues (borne de la configuration). */
private static final int SECONDES_MAX = 30;
private final CompteurTranches compteur = new CompteurTranches(TRANCHE_MS, SECONDES_MAX * TRANCHES_PAR_SECONDE + 1);
public double enregistrer(long nowMs, GardeConfig cfg, double facteur) {
fenetre.ajouter(nowMs, 0);
compteur.ajouter(nowMs);
int max = (int) Math.floor(cfg.paquetsParSecondeMax * facteur);
int secondes = Math.max(1, cfg.timerSecondesSoutenues);
int secondes = Math.min(SECONDES_MAX, Math.max(1, cfg.timerSecondesSoutenues));
int premier = 0;
for (int k = 0; k < secondes; k++) {
long jusqua = nowMs - k * 1000L + 1;
int n = fenetre.compter(jusqua - 1000, jusqua);
int n = compteur.compter(nowMs, k * TRANCHES_PAR_SECONDE, TRANCHES_PAR_SECONDE);
if (k == 0) premier = n;
if (n <= max) return 0;
}
@@ -23,6 +30,6 @@ public final class TimerPaquets {
}
public void vider() {
fenetre.vider();
compteur.vider();
}
}
+30
Voir le fichier
@@ -50,6 +50,36 @@ class AuditFaillesTest {
assertTrue(double_, "20 paquets/s comptés deux fois = 40/s : c'est pourquoi le mixin ne doit compter qu'une fois");
}
// ---------------------------------------------------------------- F02
/** Avant : au-delà de ~512 paquets/s, la fenêtre circulaire ne couvrait plus 2 s et le timer ne voyait rien. */
@Test
void F02_timer_inondation_vue() {
UUID flood = UUID.randomUUID();
boolean vu = false;
for (long t = 0; t < 8000; t++) { // 1 paquet par ms = 1000/s
if (contient(moteur.paquetMouvement(flood, t, EtatJoueur.normal()), Controle.TIMER)) vu = true;
}
assertTrue(vu, "1000 paquets/s : vu");
UUID modere = UUID.randomUUID();
boolean vuModere = false;
for (long t = 0; t < 8000; t += 10) { // 100 paquets/s
if (contient(moteur.paquetMouvement(modere, t, EtatJoueur.normal()), Controle.TIMER)) vuModere = true;
}
assertTrue(vuModere, "100 paquets/s sont bien vus (témoin)");
}
@Test
void F02_compteur_par_tranches_ne_sature_pas() {
CompteurTranches c = new CompteurTranches(50, 61);
for (int i = 0; i < 100_000; i++) c.ajouter(1000 + (i % 50)); // 100 000 événements dans une tranche
c.ajouter(950); // la tranche d'avant reste intacte
assertEquals(100_000, c.compter(1000, 0, 1));
assertEquals(1, c.compter(1000, 1, 1));
assertEquals(100_001, c.compter(1049, 0, 20));
assertEquals(0, c.compter(1000 + 61 * 50, 0, 1), "une tranche réutilisée repart de zéro");
}
// ---------------------------------------------------------------- F04
/**
* Avant : le mixin passait riptide=true dès qu'un trident Impulsion était en main, seuil vanilla 100 → 10 000