diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index f03f821..ad0657b 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -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). diff --git a/src/main/java/com/gastinelgarde/core/CompteurTranches.java b/src/main/java/com/gastinelgarde/core/CompteurTranches.java new file mode 100644 index 0000000..9607678 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/CompteurTranches.java @@ -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); + } +} diff --git a/src/main/java/com/gastinelgarde/core/TimerPaquets.java b/src/main/java/com/gastinelgarde/core/TimerPaquets.java index fb8165e..6141213 100644 --- a/src/main/java/com/gastinelgarde/core/TimerPaquets.java +++ b/src/main/java/com/gastinelgarde/core/TimerPaquets.java @@ -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(); } } diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index e7da0af..9b90048 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -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