P3.4 blink (OBSERVE par defaut) : tests

- Trou >= 30 ticks entre deux mouvements pendant lequel d'autres paquets
  (coups, clics, conteneurs, completion) arrivent a >= 2 ticks distincts,
  plus de 21 ticks apres le dernier mouvement (TCP garde l'ordre : un
  vrai lag retient tout). Un blink qui retient tout n'est pas vu.
- Tests : BlinkP06Test (9) : immobile qui clique, vrai lag, gel client,
  blink, exemptions (teleport, connexion, vehicule, gel, TPS, mort).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Opus 5.5 a révisé 2026-10-25 01:08:51 +02:00
1 Parent ad436ac213
révision 544f11dfa5
1 fichier modifié
+132
+132
Voir le fichier
@@ -0,0 +1,132 @@
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.6, P3.4 : blink (trou de mouvements pendant que d'autres paquets arrivent). */
class BlinkP06Test {
private final GardeConfig cfg = new GardeConfig();
private final UUID joueur = UUID.randomUUID();
private int mouv(Moteur m, long t, EtatJoueur e, boolean vivant) {
int n = 0;
for (Verdict v : m.mouvementBlink(joueur, t * 50L, t, e, vivant)) if (v.controle() == Controle.BLINK && v.points() > 0) n++;
return n;
}
private int mouv(Moteur m, long t) {
return mouv(m, t, EtatJoueur.normal(), true);
}
@Test
void observeParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.BLINK));
assertEquals(Controle.BLINK, Controle.parse("blink"));
}
@Test
void joueurImmobileQuiCliqueNonVu() {
// Immobile : un paquet de position toutes les 20 ticks ; il clique entre deux.
Moteur m = new Moteur(cfg);
int n = 0;
for (long t = 100; t < 1000; t += 20) {
n += mouv(m, t);
for (int k = 2; k < 20; k += 3) m.autrePaquet(joueur, t + k);
}
assertEquals(0, n);
}
@Test
void vraiLagNonVu() {
// Lag réseau : rien pendant 60 ticks, puis tout arrive dans le même tick (clics et mouvements mêlés, dans l'ordre).
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 160);
m.autrePaquet(joueur, 160);
assertEquals(0, mouv(m, 160));
}
@Test
void gelDuClientUnSeulTickNonVu() {
// Gel du client : au rattrapage, un clic part avant le mouvement du même tick client.
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 150);
assertEquals(0, mouv(m, 151));
}
@Test
void blinkVu() {
// Mouvements retenus 40 ticks, coups et clics envoyés pendant le trou.
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
m.autrePaquet(joueur, 135);
assertEquals(1, mouv(m, 140));
// le trou est soldé : le mouvement suivant normal ne compte pas
assertEquals(0, mouv(m, 141));
}
@Test
void autresPaquetsAvantLeRappelNonComptes() {
// Clics dans les 21 premiers ticks : le rappel de position vanilla n'était pas encore dû.
Moteur m = new Moteur(cfg);
mouv(m, 100);
for (long t = 101; t <= 121; t++) m.autrePaquet(joueur, t);
assertEquals(0, mouv(m, 140));
}
@Test
void blinkRepeteMonteAuPalier() {
cfg.mode(Controle.BLINK, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
boolean setback = false;
long t = 100;
mouv(m, t);
for (int i = 0; i < 10; i++) {
m.autrePaquet(joueur, t + 25);
m.autrePaquet(joueur, t + 28);
t += 32;
for (Verdict v : m.mouvementBlink(joueur, t * 50L, t, EtatJoueur.normal(), true)) {
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) setback = true;
}
}
assertTrue(setback);
}
@Test
void exemptions() {
EtatJoueur[] etats = {EtatJoueur.builder().ticksDepuisTeleport(10).build(),
EtatJoueur.builder().connexionRecente(true).build(), EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().ticksDepuisGel(50).build(), EtatJoueur.builder().tps(15).build(),
EtatJoueur.builder().creatif(true).build(), EtatJoueur.builder().spectateur(true).build()};
for (EtatJoueur e : etats) {
Moteur m = new Moteur(cfg);
mouv(m, 100, e, true);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
assertEquals(0, mouv(m, 140, e, true), e.toString());
}
// Mort : pas de mouvement sur l'écran de mort
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
assertEquals(0, mouv(m, 140, EtatJoueur.normal(), false));
}
@Test
void etatOublieALaDeconnexion() {
Moteur m = new Moteur(cfg);
mouv(m, 100);
m.autrePaquet(joueur, 125);
m.autrePaquet(joueur, 130);
m.retirer(joueur);
assertEquals(0, mouv(m, 140)); // nouveau suivi : premier mouvement, rien à solder
}
}