diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index d448d2c..27c1f95 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -16,7 +16,7 @@ Base avant corrections : 98 tests verts. | 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 | 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 | | | | +| F13 cibles saturées | corrigée | `git log --grep F13` | `AuditFaillesTest.F13_*` (rouge avant) ; 119 verts | essai en jeu n° 10 | | F20 véhicules | à faire | | | | | F11 rotation silencieuse | à faire | | | | | F19, F22, F25 | essais en jeu seulement | | | `audit/ESSAIS-EN-JEU.md` | @@ -63,3 +63,6 @@ Base avant corrections : 98 tests verts. ### 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). + +### F13 +- `CiblesMultiples` : ensemble borné (64) des cibles distinctes avec l'heure de leur dernier coup, au lieu des 32 derniers coups. Frapper une même entité en boucle met à jour une entrée, sans chasser les autres. Quand l'ensemble est plein, la cible la plus ancienne est remplacée (il faudrait 64 cibles dans la fenêtre pour saturer, ce qui est vu). diff --git a/src/main/java/com/gastinelgarde/core/CiblesMultiples.java b/src/main/java/com/gastinelgarde/core/CiblesMultiples.java index bf1c7b3..9232600 100644 --- a/src/main/java/com/gastinelgarde/core/CiblesMultiples.java +++ b/src/main/java/com/gastinelgarde/core/CiblesMultiples.java @@ -1,36 +1,51 @@ package com.gastinelgarde.core; -/** Contrôle 2 : trop d'entités différentes touchées en peu de temps. */ +/** + * Contrôle 2 : trop d'entités différentes touchées en peu de temps. + * + *
F13 : on mémorise chaque cible distincte avec l'heure de son dernier coup (ensemble borné), et non plus les + * 32 derniers coups : frapper une même entité en boucle ne met à jour qu'une entrée et ne chasse plus les autres. + * Pour saturer l'ensemble, il faudrait toucher {@link #CAPACITE} entités différentes dans la fenêtre, ce qui est + * vu. Coût mémoire constant (décision D4). + */ public final class CiblesMultiples { - private final Fenetre fenetre = new Fenetre(32); + static final int CAPACITE = 64; + + private final int[] ids = new int[CAPACITE]; + private final long[] dernierCoup = new long[CAPACITE]; + private int taille; /** * @param facteur tolérance (1.0 normal) * @return points d'infraction (0 si rien d'anormal) */ public double enregistrer(long nowMs, int idCible, GardeConfig cfg, double facteur) { - fenetre.ajouter(nowMs, idCible); + noter(nowMs, idCible); long depuis = nowMs - cfg.fenetreCiblesMs; int distinctes = 0; - int n = fenetre.taille(); - for (int i = 0; i < n; i++) { - if (fenetre.temps(i) < depuis) continue; - int id = fenetre.valeur(i); - boolean dejaVue = false; - for (int j = 0; j < i; j++) { - if (fenetre.temps(j) >= depuis && fenetre.valeur(j) == id) { - dejaVue = true; - break; - } - } - if (!dejaVue) distinctes++; + for (int i = 0; i < taille; i++) { + if (dernierCoup[i] >= depuis) distinctes++; } int max = (int) Math.floor(cfg.ciblesMax * facteur); return distinctes > max ? distinctes - max : 0; } + private void noter(long nowMs, int idCible) { + int plusAncien = 0; + for (int i = 0; i < taille; i++) { + if (ids[i] == idCible) { + dernierCoup[i] = Math.max(dernierCoup[i], nowMs); + return; + } + if (dernierCoup[i] < dernierCoup[plusAncien]) plusAncien = i; + } + int idx = taille < CAPACITE ? taille++ : plusAncien; + ids[idx] = idCible; + dernierCoup[idx] = nowMs; + } + public void vider() { - fenetre.vider(); + taille = 0; } } diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index 5cc5727..8e9730d 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -314,4 +314,20 @@ class AuditFaillesTest { 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"); } + + // ---------------------------------------------------------------- F13 + /** 8 coups par tick sur une entité chassaient les autres cibles de la fenêtre de 32 : 5 entités/s passaient. */ + @Test + void F13_cibles_multiples_vues_malgre_le_spam() { + boolean vu = false; + for (int tick = 0; tick < 200; tick++) { + long now = tick * 50L; + for (int k = 0; k < 8; k++) vu |= contient(moteur.attaque(j, now, EtatJoueur.normal(), 0, 1, true), Controle.KILLAURA_CIBLES); + if (tick % 5 == 0) { + int autre = 10 + (tick / 5) % 4; + vu |= contient(moteur.attaque(j, now, EtatJoueur.normal(), 0, autre, true), Controle.KILLAURA_CIBLES); + } + } + assertTrue(vu, "5 entités touchées par seconde : vu"); + } }