P2.3 : nouveau controle fast-break (OBSERVE par defaut)
- core.FastBreak : a la casse (BlockEvent.BreakEvent) d'un bloc dont le START a ete vu au meme endroit, rapport = getDestroyProgress x (ticks + 1). Vanilla (ServerPlayerGameMode.handleBlockBreakAction, verifie dans les sources NeoForge 21.1.234) accepte des 0,7 ; suspect sous fastBreakFacteur (0,8). - Points seulement en serie : fastBreakSerieMin (4) casses suspectes sur les 10 dernieres mesurees en 60 s. Pas de mesure : blocs < fastBreakTicksMin (6) ticks, casse instantanee, START ailleurs, creatif/spectateur, contraption et vaisseau Sable, gel du serveur, TPS bas, connexion recente. - Exemptions.Famille.MONDE (casse et pose de blocs) ; core.SerieFenetre (serie generique k sur n dans une fenetre). - En ENFORCE au palier SETBACK la casse est annulee ; expulsion comme ailleurs. - P2.2 FastEat/FastBow : rien a coder, l'usage d'objet est compte par le serveur (LivingEntity.updateUsingItem, tick du joueur par le serveur). - Reglages [monde] : fastBreakFacteur, fastBreakTicksMin, fastBreakSerieMin. - Tests : FastBreakP2Test (8). Cablage non teste en jeu. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
c49cf985d8
révision
9652b48ea6
11 fichiers modifiés
+318
-3
Aucun fichier ne correspond à votre recherche
@@ -424,6 +424,28 @@ public final class Garde {
|
||||
if (ligne != null) ecrireJournal("DIAGNOSTIC " + p.getGameProfile().getName() + " casse de bloc : " + ligne);
|
||||
}
|
||||
}
|
||||
/** 0.5 (P2.3) : START de casse accepté : début de la mesure fast-break. */
|
||||
public static void noterDebutCasse(ServerPlayer p, BlockPos pos) {
|
||||
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
|
||||
MOTEUR.debutCasse(p.getUUID(), p.server.getTickCount(), pos.getX(), pos.getY(), pos.getZ());
|
||||
}
|
||||
|
||||
/**
|
||||
* 0.5 (P2.3) : bloc cassé par ce joueur. Renvoie vrai si la casse doit être annulée (fast-break en ENFORCE, palier
|
||||
* SETBACK ou plus) ; une EXPULSION est appliquée ici.
|
||||
*/
|
||||
public static boolean noterCasse(ServerPlayer p, BlockPos pos, BlockState state) {
|
||||
if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID()) || estExempteManuellement(p.getUUID())) return false;
|
||||
if (CONFIG.mode(Controle.FAST_BREAK) == Mode.OFF) return false;
|
||||
int tick = p.server.getTickCount();
|
||||
double progression = state.getDestroyProgress(p, p.level(), pos);
|
||||
List<Verdict> v = MOTEUR.casseBloc(p.getUUID(), tick * 50L, tick, etat(p, true), pos.getX(), pos.getY(),
|
||||
pos.getZ(), progression);
|
||||
Sanction s = traiter(p, v);
|
||||
if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v);
|
||||
return Cablage.sanctionDeMouvement(s);
|
||||
}
|
||||
|
||||
public static void noterTickServeur(MinecraftServer server, long dureeNs) {
|
||||
double ms = dureeNs / 1_000_000.0;
|
||||
if (ms > 250.0) gelTick = server.getTickCount();
|
||||
|
||||
@@ -130,10 +130,25 @@ public final class GardeEvents {
|
||||
if (event.getLevel().isClientSide()) return;
|
||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
var a = event.getAction();
|
||||
// 0.5 (P2.3) : début de la mesure fast-break (START accepté par les autres mods).
|
||||
if (a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START && !event.isCanceled()) {
|
||||
Garde.noterDebutCasse(p, event.getPos());
|
||||
}
|
||||
Garde.noterActionBloc(p, a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START,
|
||||
a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.ABORT,
|
||||
event.getPos(), event.isCanceled());
|
||||
}
|
||||
/**
|
||||
* 0.5 (P2.3) : bloc cassé par un joueur (fast-break). En ENFORCE au palier SETBACK, la casse est annulée (le bloc
|
||||
* reste) ; l'expulsion s'applique comme ailleurs. Câblage non testé en jeu.
|
||||
*/
|
||||
@SubscribeEvent(priority = EventPriority.LOWEST)
|
||||
public static void onCasse(net.neoforged.neoforge.event.level.BlockEvent.BreakEvent event) {
|
||||
if (event.getLevel().isClientSide()) return;
|
||||
if (!(event.getPlayer() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
if (Garde.noterCasse(p, event.getPos(), event.getState())) event.setCanceled(true);
|
||||
}
|
||||
|
||||
/** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */
|
||||
@SubscribeEvent
|
||||
public static void onRelache(LivingEntityUseItemEvent.Stop event) {
|
||||
|
||||
@@ -30,6 +30,8 @@ public final class GardeSpec {
|
||||
// 0.5 (P2)
|
||||
private static final ModConfigSpec.DoubleValue NO_SLOW_FACTEUR;
|
||||
private static final ModConfigSpec.IntValue NO_SLOW_GRACE, NO_SLOW_TICKS;
|
||||
private static final ModConfigSpec.DoubleValue FAST_BREAK_FACTEUR;
|
||||
private static final ModConfigSpec.IntValue FAST_BREAK_TICKS_MIN, FAST_BREAK_SERIE;
|
||||
|
||||
private static final ModConfigSpec.DoubleValue ANGLE_MAX;
|
||||
private static final ModConfigSpec.IntValue CIBLES_MAX;
|
||||
@@ -277,6 +279,16 @@ public final class GardeSpec {
|
||||
.defineInRange("noSlowTicks", 10, 2, 200);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.5 (P2) : casse et pose de blocs. Nouveaux contrôles en OBSERVE par défaut.").push("monde");
|
||||
FAST_BREAK_FACTEUR = b.comment("0.5 (P2.3) fast-break : rapport (progression par tick × ticks depuis le START) sous lequel une casse est suspecte.",
|
||||
"Vanilla accepte la casse dès 0,7 ; un client honnête casse vers 1,0.")
|
||||
.defineInRange("fastBreakFacteur", 0.8, 0.7, 1.0);
|
||||
FAST_BREAK_TICKS_MIN = b.comment("Fast-break : blocs plus rapides que ce nombre de ticks non mesurés.")
|
||||
.defineInRange("fastBreakTicksMin", 6, 2, 200);
|
||||
FAST_BREAK_SERIE = b.comment("Fast-break : casses suspectes parmi les 10 dernières mesurées (60 s) avant de compter.")
|
||||
.defineInRange("fastBreakSerieMin", 4, 1, 10);
|
||||
b.pop();
|
||||
|
||||
b.comment("0.5 : diagnostics (journal seulement, jamais de sanction).").push("diagnostic");
|
||||
DIAG_ACTIONS = b.comment("Journaliser les ABORT de casse de bloc sans START correspondant (message vanilla « Mismatch in destroy block pos »),",
|
||||
"au plus une ligne toutes les 10 s par joueur.")
|
||||
@@ -449,6 +461,9 @@ public final class GardeSpec {
|
||||
c.noSlowFacteur = NO_SLOW_FACTEUR.get();
|
||||
c.noSlowGraceTicks = NO_SLOW_GRACE.get();
|
||||
c.noSlowTicks = NO_SLOW_TICKS.get();
|
||||
c.fastBreakFacteur = FAST_BREAK_FACTEUR.get();
|
||||
c.fastBreakTicksMin = FAST_BREAK_TICKS_MIN.get();
|
||||
c.fastBreakSerieMin = FAST_BREAK_SERIE.get();
|
||||
c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
|
||||
c.setbackSolSiPasDePosition = SETBACK_SOL.get();
|
||||
c.graceReculTicks = GRACE_RECUL.get();
|
||||
|
||||
@@ -31,7 +31,9 @@ public enum Controle {
|
||||
/** 0.5 (P1.8) : course au sol déclarée « en l'air » par le client pour ne pas perdre de faim (AntiHunger). */
|
||||
ANTI_FAIM("anti-faim"),
|
||||
/** 0.5 (P2.1) : vitesse de marche ou de course gardée pendant un usage d'objet (NoSlow). */
|
||||
NO_SLOW("no-slow");
|
||||
NO_SLOW("no-slow"),
|
||||
/** 0.5 (P2.3) : blocs cassés en série avant la fin de leur temps de casse (FastBreak, la marge vanilla de 30 %). */
|
||||
FAST_BREAK("fast-break");
|
||||
|
||||
private final String id;
|
||||
|
||||
@@ -60,7 +62,7 @@ public enum Controle {
|
||||
case COUPS_HORS_BOITE, KILLAURA_ANGLE, KILLAURA_CIBLES, CADENCE -> 1;
|
||||
// 0.5 : nouveaux contrôles P1 au plafond « faible » tant qu'ils n'ont pas été validés en jeu.
|
||||
case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS, ANTI_FAIM,
|
||||
NO_SLOW -> 2; // 0.5 (P2) : idem
|
||||
NO_SLOW, FAST_BREAK -> 2; // 0.5 (P2) : idem
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@@ -9,7 +9,7 @@ import java.util.List;
|
||||
*/
|
||||
public final class Exemptions {
|
||||
|
||||
public enum Famille { COMBAT, MOUVEMENT, TIMER, VEHICULE }
|
||||
public enum Famille { COMBAT, MOUVEMENT, TIMER, VEHICULE, MONDE }
|
||||
|
||||
/**
|
||||
* @param exempt le contrôle ne doit pas s'appliquer
|
||||
@@ -55,6 +55,13 @@ public final class Exemptions {
|
||||
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul");
|
||||
if (e.connexionRecente()) raisons.add("connexion");
|
||||
}
|
||||
case MONDE -> {
|
||||
// 0.5 (P2) : casse et pose de blocs. Vaisseau Sable / contraption : coordonnées de sous-niveau, et
|
||||
// gel du serveur : les paquets arrivent groupés, les temps mesurés ne veulent rien dire.
|
||||
if (e.pocheContraption()) raisons.add("contraption");
|
||||
if (e.ticksDepuisGel() <= cfg.graceGelTicks) raisons.add("gel-serveur");
|
||||
if (e.connexionRecente()) raisons.add("connexion");
|
||||
}
|
||||
case TIMER -> {
|
||||
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
|
||||
if (e.connexionRecente()) raisons.add("connexion"); // rafale de paquets du chargement
|
||||
|
||||
@@ -0,0 +1,71 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2.3) : FastBreak. Vanilla 1.21.1 (ServerPlayerGameMode.handleBlockBreakAction, vérifié dans les sources
|
||||
* NeoForge 21.1.234) accepte un STOP_DESTROY_BLOCK dès que {@code getDestroyProgress × (ticks depuis START + 1) ≥ 0,7} :
|
||||
* le serveur laisse 30 % d'avance au client. Les modules FastBreak s'arrêtent juste au-dessus de 0,7 ; un client
|
||||
* honnête envoie STOP quand sa propre progression atteint 1, donc un rapport proche de 1 (au jitter réseau près).
|
||||
*
|
||||
* Mesure, à la casse effective (BlockEvent.BreakEvent) d'un bloc dont le START a été vu au même endroit :
|
||||
* {@code rapport = progression par tick (serveur, outil et effets du moment) × (ticks écoulés + 1)}. Un rapport sous
|
||||
* {@link GardeConfig#fastBreakFacteur} (0,8) est suspect. Les blocs qui demandent moins de
|
||||
* {@link GardeConfig#fastBreakTicksMin} ticks ne sont pas mesurés (un tick de jitter y pèse trop) ; les blocs cassés
|
||||
* d'un coup (progression ≥ 1) non plus. Un START retardé par le réseau raccourcit la mesure (faux positif possible) :
|
||||
* points seulement en série ({@link GardeConfig#fastBreakSerieMin} casses suspectes sur les {@link #SERIE} dernières
|
||||
* mesurées, en {@link #FENETRE_MS} ms). OBSERVE par défaut.
|
||||
*/
|
||||
public final class FastBreak {
|
||||
|
||||
public static final int SERIE = 10;
|
||||
public static final long FENETRE_MS = 60_000;
|
||||
|
||||
private boolean debut;
|
||||
private int x, y, z;
|
||||
private long debutTick;
|
||||
private double dernierRapport = Double.NaN;
|
||||
private int dernierCompte;
|
||||
private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS);
|
||||
|
||||
/** START_DESTROY_BLOCK accepté (non annulé) sur ce bloc, au tick serveur donné. */
|
||||
public void debut(long tick, int x, int y, int z) {
|
||||
debut = true;
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
debutTick = tick;
|
||||
}
|
||||
|
||||
/**
|
||||
* Le bloc vient d'être cassé par le joueur.
|
||||
*
|
||||
* @param progression progression de casse par tick vue par le serveur ({@code getDestroyProgress}) ; NaN = inconnue
|
||||
* @return points d'infraction (0 si rien)
|
||||
*/
|
||||
public double casse(long nowMs, long tick, int x, int y, int z, double progression, GardeConfig cfg) {
|
||||
boolean memeBloc = debut && this.x == x && this.y == y && this.z == z;
|
||||
debut = false;
|
||||
dernierRapport = Double.NaN;
|
||||
if (!memeBloc || Double.isNaN(progression) || progression <= 0 || progression >= 1.0) return 0;
|
||||
long ticks = tick - debutTick;
|
||||
if (ticks < 0) return 0;
|
||||
double attendus = Math.ceil(1.0 / progression);
|
||||
if (attendus < cfg.fastBreakTicksMin) return 0;
|
||||
dernierRapport = progression * (ticks + 1);
|
||||
boolean suspect = dernierRapport < cfg.fastBreakFacteur;
|
||||
dernierCompte = serie.ajouter(nowMs, suspect);
|
||||
if (!suspect || dernierCompte < Math.max(1, cfg.fastBreakSerieMin)) return 0;
|
||||
return 2.0;
|
||||
}
|
||||
|
||||
public double dernierRapport() {
|
||||
return dernierRapport;
|
||||
}
|
||||
|
||||
public int dernierCompte() {
|
||||
return dernierCompte;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
debut = false;
|
||||
}
|
||||
}
|
||||
@@ -188,6 +188,12 @@ public final class GardeConfig {
|
||||
public int noSlowGraceTicks = 3;
|
||||
/** NoSlow : paquets suspects consécutifs avant infraction. */
|
||||
public int noSlowTicks = 10;
|
||||
/** FastBreak : rapport progression × ticks sous lequel une casse est suspecte (vanilla accepte dès 0,7). */
|
||||
public double fastBreakFacteur = 0.8;
|
||||
/** FastBreak : blocs plus rapides que ce nombre de ticks non mesurés (un tick de jitter y pèse trop). */
|
||||
public int fastBreakTicksMin = 6;
|
||||
/** FastBreak : casses suspectes parmi les 10 dernières mesurées (60 s) avant de compter. */
|
||||
public int fastBreakSerieMin = 4;
|
||||
|
||||
// --- 0.5 (P1.13, section [diagnostic]) : journal seulement, jamais de sanction ---
|
||||
/** Journaliser les ABORT de casse de bloc sans START correspondant (« Mismatch in destroy block pos »). */
|
||||
|
||||
@@ -475,6 +475,35 @@ public final class Moteur {
|
||||
return verdicts;
|
||||
}
|
||||
|
||||
// --- 0.5 (P2) : casse et pose de blocs -------------------------------------------------------------
|
||||
|
||||
/** START_DESTROY_BLOCK accepté (non annulé par un mod) : début de la mesure fast-break. */
|
||||
public void debutCasse(UUID joueur, long tick, int x, int y, int z) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.FAST_BREAK) == Mode.OFF) return;
|
||||
suivi(joueur).fastBreak.debut(tick, x, y, z);
|
||||
}
|
||||
|
||||
/**
|
||||
* Un bloc vient d'être cassé par le joueur (BlockEvent.BreakEvent).
|
||||
*
|
||||
* @param progression {@code getDestroyProgress} du bloc pour ce joueur (par tick) ; NaN si inconnue
|
||||
*/
|
||||
public List<Verdict> casseBloc(UUID joueur, long nowMs, long tick, EtatJoueur etat, int x, int y, int z, double progression) {
|
||||
if (expulses.contains(joueur) || cfg.mode(Controle.FAST_BREAK) == Mode.OFF) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE);
|
||||
if (ex.exempt() || etat.tps() < cfg.tpsLag) {
|
||||
s.fastBreak.vider();
|
||||
return List.of();
|
||||
}
|
||||
double pts = s.fastBreak.casse(nowMs, tick, x, y, z, progression, cfg);
|
||||
List<Verdict> v = new ArrayList<>(1);
|
||||
ajouter(v, s, Controle.FAST_BREAK, pts, nowMs, ex, String.format(Locale.ROOT,
|
||||
"bloc casse a %.2f du temps vanilla (seuil %.2f), %d casses suspectes sur %d",
|
||||
s.fastBreak.dernierRapport(), cfg.fastBreakFacteur, s.fastBreak.dernierCompte(), FastBreak.SERIE));
|
||||
return v;
|
||||
}
|
||||
|
||||
/**
|
||||
* L'exemption tient-elle à un état dont la fin arrive en retard côté serveur (élytres, riptide, véhicule, vol,
|
||||
* contraption, lévitation, chute lente, mode de jeu) ? Une grâce seule (téléportation, recul) : non.
|
||||
|
||||
@@ -0,0 +1,42 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
/**
|
||||
* 0.5 (P2) : série générique « k suspects parmi les n dernières mesures, dans une fenêtre de temps », comme
|
||||
* {@link SerieCoups} mais sans réglage lu dans la configuration. Tampon de taille fixe, aucune allocation.
|
||||
*/
|
||||
public final class SerieFenetre {
|
||||
|
||||
private final int n;
|
||||
private final long fenetreMs;
|
||||
private final long[] instants;
|
||||
private final boolean[] suspects;
|
||||
private int taille;
|
||||
private int tete;
|
||||
|
||||
public SerieFenetre(int n, long fenetreMs) {
|
||||
this.n = Math.max(1, n);
|
||||
this.fenetreMs = fenetreMs;
|
||||
this.instants = new long[this.n];
|
||||
this.suspects = new boolean[this.n];
|
||||
}
|
||||
|
||||
/** Ajoute une mesure ; renvoie le nombre de suspectes parmi les n dernières encore dans la fenêtre. */
|
||||
public int ajouter(long nowMs, boolean suspect) {
|
||||
instants[tete] = nowMs;
|
||||
suspects[tete] = suspect;
|
||||
tete = (tete + 1) % n;
|
||||
if (taille < n) taille++;
|
||||
int compte = 0;
|
||||
for (int k = 0; k < taille; k++) {
|
||||
int i = ((tete - 1 - k) % n + n) % n;
|
||||
if (nowMs - instants[i] > fenetreMs || instants[i] > nowMs) break;
|
||||
if (suspects[i]) compte++;
|
||||
}
|
||||
return compte;
|
||||
}
|
||||
|
||||
public void vider() {
|
||||
taille = 0;
|
||||
tete = 0;
|
||||
}
|
||||
}
|
||||
@@ -67,6 +67,8 @@ public final class Suivi {
|
||||
public final AntiFaim antiFaim = new AntiFaim();
|
||||
/** 0.5 (P2.1) : no-slow. */
|
||||
public final NoSlow noSlow = new NoSlow();
|
||||
/** 0.5 (P2.3) : fast-break. */
|
||||
public final FastBreak fastBreak = new FastBreak();
|
||||
/** 0.5 (P1.6) : déploiements d'élytres répétés. */
|
||||
public final DeploiementsElytres deploiements = new DeploiementsElytres();
|
||||
/** 0.5 (P1.13) : diagnostic des actions de casse de bloc. */
|
||||
|
||||
@@ -0,0 +1,104 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/** 0.5, P2.3 : fast-break (progression simulée comme ServerPlayerGameMode). */
|
||||
class FastBreakP2Test {
|
||||
|
||||
private final GardeConfig cfg = new GardeConfig();
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
/**
|
||||
* Casse {@code n} blocs successifs (pierre à la pioche en bois : progression 1/15 par tick environ), chacun en
|
||||
* {@code ticksCasse} ticks après son START. Renvoie le total des points fast-break.
|
||||
*/
|
||||
private double casser(Moteur m, EtatJoueur etat, int n, double progression, int ticksCasse) {
|
||||
double pts = 0;
|
||||
long tick = 1000;
|
||||
for (int i = 0; i < n; i++) {
|
||||
m.debutCasse(joueur, tick, i, 10, 0);
|
||||
tick += ticksCasse;
|
||||
for (Verdict v : m.casseBloc(joueur, tick * 50L, tick, etat, i, 10, 0, progression)) {
|
||||
if (v.controle() == Controle.FAST_BREAK) pts += v.points();
|
||||
}
|
||||
tick += 2;
|
||||
}
|
||||
return pts;
|
||||
}
|
||||
|
||||
@Test
|
||||
void observeParDefaut() {
|
||||
assertEquals(Mode.OBSERVE, cfg.mode(Controle.FAST_BREAK));
|
||||
assertEquals(Controle.FAST_BREAK, Controle.parse("fast-break"));
|
||||
assertEquals(2, Controle.FAST_BREAK.fiabilite());
|
||||
}
|
||||
|
||||
@Test
|
||||
void casseALaMargeVanillaEnSerieVue() {
|
||||
// 15 ticks attendus ; casse à 0,7 : progression × (j + 1) >= 0,7 => j = 10.
|
||||
double p = 1.0 / 15;
|
||||
assertTrue(casser(new Moteur(cfg), EtatJoueur.normal(), 10, p, 10) > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void casseHonneteJamaisVue() {
|
||||
double p = 1.0 / 15;
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 50, p, 14), 1e-9); // rapport 1,0
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 50, p, 12), 1e-9); // 0,87 : jitter de 2 ticks
|
||||
}
|
||||
|
||||
@Test
|
||||
void casseSuspecteIsoleeNeComptePas() {
|
||||
// 3 suspectes sur 10 (seuil 4) : rien.
|
||||
Moteur m = new Moteur(cfg);
|
||||
double p = 1.0 / 15;
|
||||
double pts = casser(m, EtatJoueur.normal(), 7, p, 14);
|
||||
pts += casser(m, EtatJoueur.normal(), 3, p, 10);
|
||||
assertEquals(0, pts, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void blocsRapidesEtInstantanesNonMesures() {
|
||||
// 4 ticks attendus (< fastBreakTicksMin 6) et casse instantanée (progression >= 1) : jamais mesurés.
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 20, 0.25, 1), 1e-9);
|
||||
assertEquals(0, casser(new Moteur(cfg), EtatJoueur.normal(), 20, 1.5, 0), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void casseSansStartAuMemeEndroitNonMesuree() {
|
||||
Moteur m = new Moteur(cfg);
|
||||
double pts = 0;
|
||||
for (int i = 0; i < 20; i++) {
|
||||
m.debutCasse(joueur, 100 + i * 20, 0, 0, 0);
|
||||
for (Verdict v : m.casseBloc(joueur, (110 + i * 20) * 50L, 110 + i * 20, EtatJoueur.normal(), 5, 5, 5, 1.0 / 15)) {
|
||||
pts += v.points();
|
||||
}
|
||||
}
|
||||
assertEquals(0, pts, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void exemptions() {
|
||||
double p = 1.0 / 15;
|
||||
for (EtatJoueur e : new EtatJoueur[] {
|
||||
EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build(),
|
||||
EtatJoueur.builder().pocheContraption(true).build(), EtatJoueur.builder().ticksDepuisGel(10).build(),
|
||||
EtatJoueur.builder().tps(15).build()}) {
|
||||
assertEquals(0, casser(new Moteur(cfg), e, 20, p, 10), 1e-9, e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void serieFenetreCompteLesDernieres() {
|
||||
SerieFenetre s = new SerieFenetre(3, 1000);
|
||||
assertEquals(1, s.ajouter(0, true));
|
||||
assertEquals(2, s.ajouter(10, true));
|
||||
assertEquals(2, s.ajouter(20, false));
|
||||
assertEquals(1, s.ajouter(30, false)); // la première est sortie des 3 dernières
|
||||
assertEquals(1, s.ajouter(2000, true)); // les autres sont hors fenêtre
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur