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

+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