Comparer les révisions
3
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
d9530d0661 | |||
|
|
9335654541 | |||
|
|
56a98f3a5c | |||
Aucun fichier ne correspond à votre recherche
@@ -547,6 +547,7 @@ public final class Garde {
|
||||
/** Début du traitement d'un paquet de mouvement : contrôle du débit. */
|
||||
public static void avantMouvement(ServerPlayer p) {
|
||||
if (!surThreadServeur(p)) return; // F01 : jamais depuis le thread réseau (le mixin l'évite déjà)
|
||||
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 : expulsion en cours, plus rien à évaluer
|
||||
if (estExempteManuellement(p.getUUID())) return;
|
||||
EtatJoueur etat = etat(p, false);
|
||||
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
|
||||
@@ -557,6 +558,7 @@ public final class Garde {
|
||||
/** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */
|
||||
public static void apresMouvement(ServerPlayer p) {
|
||||
if (!surThreadServeur(p)) return;
|
||||
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 / C6 : ni évaluation ni état recréé après l'expulsion
|
||||
int tick = p.server.getTickCount();
|
||||
Marques m = marques(p.getUUID());
|
||||
boolean solServeur = auSolServeur(p, m);
|
||||
@@ -601,7 +603,9 @@ public final class Garde {
|
||||
|
||||
// En véhicule, la position du joueur est celle du véhicule, non contrôlée ici : elle n'est mémorisée
|
||||
// qu'après un paquet de véhicule sans verdict (apresVehicule), sinon un setback y ramènerait.
|
||||
if (m.dernierVerdictTick != tick && !vehiculeControle(p)) {
|
||||
// C3 (16/10) : seulement au sol vu par le serveur (ou eau, échelle…), jamais une position en l'air.
|
||||
if (m.dernierVerdictTick != tick && !vehiculeControle(p)
|
||||
&& MOTEUR.positionDeRetourAdmise(solServeur, em != null && em.milieuSpecial())) {
|
||||
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
|
||||
p.level().dimension().location().toString());
|
||||
}
|
||||
@@ -870,6 +874,8 @@ public final class Garde {
|
||||
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
|
||||
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
|
||||
if (s == Sanction.EXPULSION) {
|
||||
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
|
||||
if (!MOTEUR.expulser(p.getUUID(), p.server.getTickCount() * 50L)) return;
|
||||
ecrireJournal(p.getGameProfile().getName() + " EXPULSE (" + raison + ")");
|
||||
p.connection.disconnect(Component.literal("Expulsé par l'anti-triche (" + raison + ")."));
|
||||
} else if (s == Sanction.SETBACK) {
|
||||
@@ -878,6 +884,8 @@ public final class Garde {
|
||||
if (sv.aPositionValide() && sv.dimension().equals(dim)) {
|
||||
annoncerTeleport(p, GraceTeleport.Origine.SETBACK);
|
||||
p.connection.teleport(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
|
||||
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
|
||||
MOTEUR.apresSetback(p.getUUID(), p.server.getTickCount() * 50L);
|
||||
ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -57,6 +57,10 @@ public final class GardeEvents {
|
||||
@SubscribeEvent
|
||||
public static void onAttaque(AttackEntityEvent event) {
|
||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
if (Garde.moteur().estExpulse(p.getUUID())) { // C4 : expulsion en cours
|
||||
event.setCanceled(true);
|
||||
return;
|
||||
}
|
||||
if (Garde.estExempteManuellement(p.getUUID())) return;
|
||||
|
||||
Entity cible = event.getTarget();
|
||||
@@ -135,7 +139,10 @@ public final class GardeEvents {
|
||||
|
||||
@SubscribeEvent
|
||||
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
|
||||
if (event.getEntity() instanceof ServerPlayer p) Garde.noterTeleport(p);
|
||||
if (event.getEntity() instanceof ServerPlayer p) {
|
||||
Garde.moteur().oublierExpulsion(p.getUUID()); // C4 : la marque d'expulsion vaut jusqu'à la reconnexion
|
||||
Garde.noterTeleport(p);
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeEvent
|
||||
|
||||
@@ -17,6 +17,14 @@ public final class GardeConfig {
|
||||
public double seuilExpulsion = 20.0;
|
||||
/** Sanction la plus forte autorisée (T4 : setback puis expulsion, jamais de bannissement). */
|
||||
public Sanction sanctionMax = Sanction.EXPULSION;
|
||||
/**
|
||||
* C5 (16/10) : un retour en arrière remet le VL du contrôle à zéro ; l'expulsion pour un contrôle de mouvement
|
||||
* vient quand ce nombre de setbacks a déjà eu lieu dans {@link #fenetreSetbacksMs}.
|
||||
*/
|
||||
public int setbacksAvantExpulsion = 4;
|
||||
public long fenetreSetbacksMs = 60_000;
|
||||
/** C1 (16/10) : ticks de grâce du contrôle vol après la fin du plané en élytres (fin à l'atterrissage). */
|
||||
public int graceFinElytresTicks = 50;
|
||||
|
||||
// --- Killaura ---
|
||||
/** Angle maximal entre le regard et la silhouette de la cible, en degrés. */
|
||||
|
||||
@@ -21,6 +21,8 @@ public final class Moteur {
|
||||
|
||||
private final GardeConfig cfg;
|
||||
private final Map<UUID, Suivi> suivis = new HashMap<>();
|
||||
/** C4 : joueurs déjà expulsés (jusqu'à leur reconnexion). */
|
||||
private final java.util.Set<UUID> expulses = new java.util.HashSet<>();
|
||||
|
||||
public Moteur(GardeConfig cfg) {
|
||||
this.cfg = cfg;
|
||||
@@ -54,6 +56,7 @@ public final class Moteur {
|
||||
*/
|
||||
public List<Verdict> attaque(UUID joueur, long nowMs, EtatJoueur etat, double excedentDegres,
|
||||
int idCible, boolean cibleVisible) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
|
||||
if (ex.exempt()) return List.of();
|
||||
|
||||
@@ -97,6 +100,7 @@ public final class Moteur {
|
||||
*/
|
||||
public List<Verdict> porteeHitbox(UUID joueur, long nowMs, EtatJoueur etat, double distance, double manque,
|
||||
double porteeJoueur, double vitesseCible) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
boolean portee = cfg.mode(Controle.PORTEE) != Mode.OFF;
|
||||
boolean hitbox = cfg.mode(Controle.HITBOX) != Mode.OFF;
|
||||
if (!portee && !hitbox) return List.of();
|
||||
@@ -165,6 +169,7 @@ public final class Moteur {
|
||||
double[] boite, double porteeJoueur, double vitesseCible,
|
||||
boolean porteeHitbox, boolean angle, double[] oeilPrecedent,
|
||||
double[][] boitesVues) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
List<Verdict> verdicts = terminerCoup(joueur);
|
||||
boolean serie = porteeHitbox && boitesVues != null && boitesVues.length > 0
|
||||
&& cfg.mode(Controle.COUPS_HORS_BOITE) != Mode.OFF;
|
||||
@@ -224,6 +229,7 @@ public final class Moteur {
|
||||
|
||||
/** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */
|
||||
public List<Verdict> regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
Suivi s = suivis.get(joueur);
|
||||
if (s == null || s.coupDiffere == null) return List.of();
|
||||
if (s.coupDiffere.encoreValable(nowMs)) s.coupDiffere.affiner(oeil, regard);
|
||||
@@ -270,6 +276,7 @@ public final class Moteur {
|
||||
*/
|
||||
public List<Verdict> regard(UUID joueur, long nowMs, java.util.function.Supplier<EtatJoueur> etat,
|
||||
float yaw, float pitch) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
if (cfg.mode(Controle.ROTATION) == Mode.OFF) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
double pts = s.rotation.regard(nowMs / 50, yaw, pitch);
|
||||
@@ -285,6 +292,7 @@ public final class Moteur {
|
||||
|
||||
/** Un paquet de mouvement vient d'arriver (temps réel en ms, pour mesurer le débit). */
|
||||
public List<Verdict> paquetMouvement(UUID joueur, long nowMs, EtatJoueur etat) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
if (cfg.mode(Controle.TIMER) == Mode.OFF) return List.of();
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER);
|
||||
if (ex.exempt()) {
|
||||
@@ -304,6 +312,7 @@ public final class Moteur {
|
||||
* Les exemptions de mouvement (riptide, élytres, contraption, téléportation, recul…) coupent tout.
|
||||
*/
|
||||
public List<Verdict> mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
boolean noFall = cfg.mode(Controle.NO_FALL) != Mode.OFF;
|
||||
boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF;
|
||||
boolean vol = cfg.mode(Controle.VOL) != Mode.OFF;
|
||||
@@ -315,6 +324,10 @@ public final class Moteur {
|
||||
// 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…).
|
||||
s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons()));
|
||||
s.vol.vider();
|
||||
// C1 (16/10, incident Rednixxu) : le drapeau élytres tombe côté serveur alors que le client plane encore.
|
||||
if (ex.raisons().contains("elytres")) {
|
||||
s.graceElytresJusquaMs = nowMs + cfg.graceFinElytresTicks * 50L;
|
||||
}
|
||||
return List.of();
|
||||
}
|
||||
List<Verdict> verdicts = new ArrayList<>(3);
|
||||
@@ -328,7 +341,15 @@ public final class Moteur {
|
||||
String.format(Locale.ROOT, "dxz=%.3f max=%.3f ticks=%d base=%.3f", m.dxz(),
|
||||
s.vitesse.dernierPermis() * Math.max(1, m.ticks()), m.ticks(), VitesseHorizontale.vitesseMax(m)));
|
||||
}
|
||||
if (vol) {
|
||||
boolean graceElytres = false;
|
||||
if (m.auSolServeur()) {
|
||||
s.graceElytresJusquaMs = Long.MIN_VALUE; // atterrissage : fin de la grâce de fin d'élytres
|
||||
} else if (nowMs <= s.graceElytresJusquaMs) {
|
||||
graceElytres = true;
|
||||
}
|
||||
if (vol && graceElytres) {
|
||||
s.vol.vider(); // le paquet qui suit la grâce sert de référence
|
||||
} else if (vol) {
|
||||
double pts = s.vol.enregistrer(m, false);
|
||||
ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy()));
|
||||
}
|
||||
@@ -350,6 +371,7 @@ public final class Moteur {
|
||||
* Un mouvement de véhicule piloté par le joueur, accepté par le serveur (F20) : vitesse et vol du véhicule.
|
||||
*/
|
||||
public List<Verdict> vehicule(UUID joueur, long nowMs, EtatJoueur etat, EtatVehicule m) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
boolean vitesse = cfg.mode(Controle.VEHICULE_VITESSE) != Mode.OFF;
|
||||
boolean vol = cfg.mode(Controle.VEHICULE_VOL) != Mode.OFF;
|
||||
if (!vitesse && !vol) return List.of();
|
||||
@@ -395,6 +417,49 @@ public final class Moteur {
|
||||
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
|
||||
}
|
||||
|
||||
// --- Setback, expulsion, position de retour (16/10, incident VOL) ----------------------------------------
|
||||
|
||||
/**
|
||||
* C2 (16/10) : un retour en arrière vient d'être appliqué. Le contrôle vol et la vitesse repartent de zéro (le
|
||||
* paquet suivant sert de référence) et leurs VL sont remis à zéro ; le setback est compté pour l'escalade (C5).
|
||||
*/
|
||||
public void apresSetback(UUID joueur, long nowMs) {
|
||||
Suivi s = suivi(joueur);
|
||||
s.vol.vider();
|
||||
s.vitesse.vider();
|
||||
s.graceElytresJusquaMs = Long.MIN_VALUE;
|
||||
s.vl.remettreAZero(Controle.VOL);
|
||||
s.vl.remettreAZero(Controle.VITESSE);
|
||||
s.noterSetback(nowMs);
|
||||
}
|
||||
|
||||
/**
|
||||
* C4 (16/10) : expulsion à usage unique. Vrai la première fois seulement ; ensuite le joueur n'est plus évalué
|
||||
* jusqu'à sa reconnexion ({@link #oublierExpulsion}). La marque survit à {@link #retirer} (C6).
|
||||
*/
|
||||
public boolean expulser(UUID joueur, long nowMs) {
|
||||
return expulses.add(joueur);
|
||||
}
|
||||
|
||||
public boolean estExpulse(UUID joueur) {
|
||||
return expulses.contains(joueur);
|
||||
}
|
||||
|
||||
/** Reconnexion du joueur : il repart d'un état neuf. */
|
||||
public void oublierExpulsion(UUID joueur) {
|
||||
expulses.remove(joueur);
|
||||
suivis.remove(joueur);
|
||||
}
|
||||
|
||||
/**
|
||||
* C3 (16/10) : la position d'un paquet sans verdict ne sert de retour en arrière que si le joueur est au sol vu
|
||||
* par le serveur (ou dans un milieu où la gravité vanilla ne s'applique pas : eau, échelle…). Avant, toute
|
||||
* position était gardée, y compris pendant les 10 ticks anormaux tolérés : retour en l'air.
|
||||
*/
|
||||
public boolean positionDeRetourAdmise(boolean auSolServeur, boolean milieuSpecial) {
|
||||
return auSolServeur || milieuSpecial;
|
||||
}
|
||||
|
||||
// --- Interne ----------------------------------------------------------------------------------------
|
||||
|
||||
private void ajouter(List<Verdict> sortie, Suivi s, Controle c, double points, long nowMs,
|
||||
@@ -403,6 +468,11 @@ public final class Moteur {
|
||||
Mode mode = cfg.mode(c);
|
||||
double vl = s.vl.ajouter(c, points, nowMs);
|
||||
Sanction palier = Paliers.palier(vl, cfg);
|
||||
// C5 (16/10) : après un setback, le VL repart de zéro ; l'expulsion vient après plusieurs setbacks récents.
|
||||
if (palier == Sanction.SETBACK && cfg.setbacksAvantExpulsion > 0
|
||||
&& s.setbacksRecents(nowMs, cfg.fenetreSetbacksMs) >= cfg.setbacksAvantExpulsion) {
|
||||
palier = Sanction.min(Sanction.EXPULSION, cfg.sanctionMax);
|
||||
}
|
||||
Sanction applicable = Paliers.applicable(palier, mode);
|
||||
boolean notifier = applicable.ordinal() >= Sanction.ALERTE.ordinal()
|
||||
&& s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS);
|
||||
|
||||
@@ -21,6 +21,22 @@ public final class Suivi {
|
||||
CoupDiffere coupDiffere;
|
||||
/** Jusqu'à quand (ms) les coups sont annulés après une sanction portée / hitbox en ENFORCE. */
|
||||
long coupsBloquesJusqua = Long.MIN_VALUE;
|
||||
/** C1 (16/10) : fin de la grâce du contrôle vol après le plané en élytres (ms). */
|
||||
long graceElytresJusquaMs = Long.MIN_VALUE;
|
||||
/** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */
|
||||
private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>();
|
||||
|
||||
void noterSetback(long nowMs) {
|
||||
setbacks.addLast(nowMs);
|
||||
while (setbacks.size() > 32) setbacks.removeFirst();
|
||||
}
|
||||
|
||||
/** Nombre de setbacks dans la fenêtre {@code fenetreMs} qui précède {@code nowMs}. */
|
||||
int setbacksRecents(long nowMs, long fenetreMs) {
|
||||
int n = 0;
|
||||
for (long t : setbacks) if (nowMs - t <= fenetreMs) n++;
|
||||
return n;
|
||||
}
|
||||
|
||||
// Dernière position jugée valide (retour en arrière).
|
||||
private boolean positionValide;
|
||||
|
||||
@@ -42,6 +42,11 @@ public final class VlCompteur {
|
||||
etats.clear();
|
||||
}
|
||||
|
||||
/** C2 (16/10) : remet à zéro un seul contrôle (après un setback). */
|
||||
public void remettreAZero(Controle c) {
|
||||
etats.remove(c);
|
||||
}
|
||||
|
||||
private double decayed(Etat e, long nowMs) {
|
||||
if (nowMs <= e.dernierMs) return e.valeur;
|
||||
double perdu = (nowMs - e.dernierMs) / 1000.0 * decroissanceParSeconde;
|
||||
|
||||
@@ -14,9 +14,9 @@ import org.junit.jupiter.api.Test;
|
||||
/**
|
||||
* Autotests du 16/10/2026, nuit : incident VOL de Rednixxu (15/10, 17:31) et constats C1 à C5, C10 de l'autocritique.
|
||||
*
|
||||
* Ces tests DOCUMENTENT le comportement actuel, ils ne corrigent rien : un test nommé {@code FAILLE_…} ou
|
||||
* {@code FAUX_POSITIF_…} passe tant que le défaut existe. Quand le défaut sera corrigé, il échouera : il faudra alors
|
||||
* inverser son assertion (c'est voulu, pour que la correction soit vue).
|
||||
* C1 à C5 corrigés le 16/10 (branche fix/vol-elytres) : les anciens tests {@code FAUX_POSITIF_…} / {@code FAILLE_…}
|
||||
* ont été inversés et renommés {@code CORRIGE_…}. C10 n'est pas corrigé : ses tests {@code FAILLE_…} passent tant que
|
||||
* le défaut existe.
|
||||
*
|
||||
* Ce qui se passe dans l'adaptateur (Garde.java, qui dépend de Minecraft) est rejoué ici par un petit modèle écrit
|
||||
* d'après le code : position mémorisée après un paquet sans verdict (Garde.apresMouvement), paquet suivant un
|
||||
@@ -67,7 +67,8 @@ class AutotestVolIncidentTest {
|
||||
tick++;
|
||||
y += m.dy();
|
||||
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, e, m);
|
||||
if (vs.isEmpty()) { // Garde.apresMouvement : m.dernierVerdictTick != tick
|
||||
// Garde.apresMouvement : m.dernierVerdictTick != tick, et (16/10, C3) position admise (au sol serveur)
|
||||
if (vs.isEmpty() && moteur.positionDeRetourAdmise(m.auSolServeur(), m.milieuSpecial())) {
|
||||
yRetour = y;
|
||||
retourAuSol = m.auSolServeur();
|
||||
}
|
||||
@@ -94,24 +95,46 @@ class AutotestVolIncidentTest {
|
||||
return sortie;
|
||||
}
|
||||
|
||||
// --- C1 : pas de grâce de sortie d'élytres pour le vol ----------------------------------------------------------
|
||||
/** Plané anormal depuis le sol, sans élytres (triche de type « glide ») : de quoi déclencher des setbacks. */
|
||||
private EtatMouvement plane() {
|
||||
return air(-0.02);
|
||||
}
|
||||
|
||||
// --- C1 : grâce de sortie d'élytres pour le vol (corrigé le 16/10) ----------------------------------------------
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C1_planeDElytresDontLeDrapeauTombeEstPrisPourDuVol() {
|
||||
void CORRIGE_C1_planeDElytresDontLeDrapeauTombeNEstPlusPrisPourDuVol() {
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
|
||||
int premier = -1;
|
||||
double total = 0;
|
||||
for (int k = 0; k < vs.size(); k++) {
|
||||
double p = points(vs.get(k), Controle.VOL);
|
||||
if (p > 0 && premier < 0) premier = k + 1;
|
||||
total += p;
|
||||
for (List<Verdict> v : vs) total += points(v, Controle.VOL);
|
||||
// Avant : premier point au 12e tick, 11,6 points en 19 ticks (incident de Rednixxu).
|
||||
assertEquals(0, total, 1e-9, "grâce de fin d'élytres : la trace de Rednixxu ne donne plus rien");
|
||||
Mesures.noter("C1 corrige : 19 ticks de plane sans drapeau = " + total + " point");
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_C1_laGraceDeFinDElytresEstBorneeDansLeTemps() {
|
||||
// Témoin : un plané sans drapeau qui dure bien au-delà de la grâce finit par être vu.
|
||||
// 16/10 : témoin corrigé. L'ancien (accélération 0,02 bloc/tick² prolongée) entre dans la tolérance de
|
||||
// VolVertical (0,05) dès ~22 ticks et n'était donc jamais puni après 50 ticks de grâce, même sans grâce.
|
||||
// Plané constant à -0,05 bloc/tick : écart ~0,077 à chaque tick, nettement anormal.
|
||||
sautPuisPlaneSansDrapeau(1);
|
||||
double total = 0;
|
||||
for (int k = 0; k < cfg.graceFinElytresTicks + 30; k++) {
|
||||
total += points(paquet(EtatJoueur.normal(), air(-0.05)), Controle.VOL);
|
||||
}
|
||||
// Prouvé : le 1er paquet après l'exemption sert de référence, les suivants sont tous « anormaux » ; le 12e tick
|
||||
// de plané sans drapeau donne le premier point (journal réel : 13 ticks après la chute du drapeau, vl=1.1).
|
||||
assertEquals(12, premier, "premier tick de plané puni");
|
||||
assertEquals(1.1, points(vs.get(11), Controle.VOL), 1e-9);
|
||||
assertTrue(total > cfg.seuilSetback, "19 ticks de plané suffisent à dépasser le seuil de setback");
|
||||
Mesures.noter("C1 premier point au tick " + premier + " de plane sans drapeau ; total 19 ticks = " + total);
|
||||
assertTrue(total > 0, "après la grâce, un plané anormal est de nouveau puni");
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_C1_laGraceSeTermineALAtterrissage() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 20; i++) paquet(elytres, air(-0.3));
|
||||
for (int i = 0; i < 3; i++) paquet(EtatJoueur.normal(), sol()); // atterrissage : fin de la grâce
|
||||
double total = 0;
|
||||
for (int i = 0; i < 20; i++) total += points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL);
|
||||
assertTrue(total > 0, "voler juste après un atterrissage d'élytres reste vu");
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -127,102 +150,94 @@ class AutotestVolIncidentTest {
|
||||
assertEquals(0, total, 1e-9, "réfuté : une fin d'élytres suivie d'une chute vanilla ne donne rien");
|
||||
}
|
||||
|
||||
// --- C3 : point de retour mémorisé en l'air -----------------------------------------------------------------------
|
||||
// --- C3 : point de retour au sol (corrigé le 16/10) --------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C3_pointDeRetourMemoriseEnLAirSousLaPlateforme() {
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(12);
|
||||
assertTrue(points(vs.get(11), Controle.VOL) > 0);
|
||||
assertFalse(retourAuSol, "la position de retour vient d'un paquet en l'air");
|
||||
assertTrue(yRetour < Y_SOL, "et elle est sous la plateforme d'où il a sauté : " + yRetour);
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT,
|
||||
"C3 retour en l'air a y=%.3f (sol %.3f, ecart %.3f ; journal reel : 109,685, ecart 1,19)",
|
||||
yRetour, Y_SOL, Y_SOL - yRetour));
|
||||
void CORRIGE_C3_pointDeRetourResteAuSolPendantUnPlane() {
|
||||
sautPuisPlaneSansDrapeau(12);
|
||||
assertTrue(retourAuSol, "la position de retour vient d'un paquet au sol serveur");
|
||||
assertEquals(Y_SOL, yRetour, 1e-9, "et c'est la plateforme d'où il a sauté");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C3_unVolDeDixTicksGardeLAltitudeGagneeDansLePointDeRetour() {
|
||||
void CORRIGE_C3_unVolDeDixTicksNeGardePasLAltitudeGagnee() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
int premier = -1;
|
||||
for (int k = 1; k <= 15 && premier < 0; k++) {
|
||||
if (points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL) > 0) premier = k;
|
||||
}
|
||||
assertTrue(premier > 10, "le vol n'est vu qu'après 10 ticks anormaux");
|
||||
assertFalse(retourAuSol);
|
||||
assertTrue(yRetour - Y_SOL >= 0.9, "le setback ramène à l'altitude gagnée en volant : +" + (yRetour - Y_SOL));
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT, "C3 tricheur : retour a +%.2f bloc au-dessus du sol",
|
||||
yRetour - Y_SOL));
|
||||
assertTrue(retourAuSol);
|
||||
assertEquals(Y_SOL, yRetour, 1e-9, "le setback ramène au sol de départ, pas à l'altitude gagnée");
|
||||
}
|
||||
|
||||
// --- C2, C5, C4 : setback sans remise à zéro, escalade en moins d'une seconde, expulsion répétée ------------------
|
||||
// --- C2, C5, C4 : setback remis à zéro, escalade, expulsion unique (corrigés le 16/10) ---------------------------
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C2_setbackNOuvreAucuneGraceEtNeRemetPasLeVolAZero() {
|
||||
GraceTeleport g = new GraceTeleport();
|
||||
g.annoncer(GraceTeleport.Origine.SETBACK);
|
||||
assertFalse(g.teleport(), "le setback n'ouvre pas la grâce de téléportation");
|
||||
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
|
||||
int k = 0;
|
||||
while (Verdict.pire(vs.get(k)) != Sanction.SETBACK) k++; // premier SETBACK
|
||||
// Modèle de l'adaptateur : teleport() vers le point de retour ; le paquet suivant n'est pas mesuré.
|
||||
tick++;
|
||||
/** Modèle de Garde.appliquerSanctionMouvement (SETBACK) : téléportation au point de retour puis remise à zéro. */
|
||||
private void setback() {
|
||||
moteur.apresSetback(joueur, tick * 50L);
|
||||
tick++; // teleport() : le paquet suivant n'est pas mesuré (Garde.teleportVanilla)
|
||||
y = yRetour;
|
||||
// Joueur gelé en l'air au point de retour (dy = 0, gravité absente tant que la téléportation n'est pas
|
||||
// confirmée : « kicked for floating too long » x302 dans le journal du 15/10).
|
||||
for (int i = 0; i < 5; i++) {
|
||||
List<Verdict> v = paquet(EtatJoueur.normal(), air(0));
|
||||
assertTrue(points(v, Controle.VOL) > 0, "paquet gelé " + i + " après le setback encore puni");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C5_C4_cinqSetbacksPuisExpulsionEnMoinsDUneSecondeEtExpulsionRepetee() {
|
||||
void CORRIGE_C2_apresUnSetbackLeVolEtLesVlRepartentDeZero() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double v = 0.42;
|
||||
int n = 0;
|
||||
while (Verdict.pire(paquet(EtatJoueur.normal(), plane())) != Sanction.SETBACK) assertTrue(++n < 100);
|
||||
assertTrue(retourAuSol, "point de retour au sol");
|
||||
setback();
|
||||
assertEquals(0, moteur.suivi(joueur).vl.valeur(Controle.VOL, tick * 50L), 1e-9, "VL de vol remis à zéro");
|
||||
// Le client, ramené au sol, reste immobile quelques paquets (téléportation pas encore confirmée) : rien.
|
||||
for (int i = 0; i < 5; i++) {
|
||||
paquet(EtatJoueur.normal(), air(v));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
List<Verdict> v = paquet(EtatJoueur.normal(), sol());
|
||||
assertEquals(0, points(v, Controle.VOL), 1e-9, "paquet " + i + " après le setback");
|
||||
}
|
||||
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 7; i++) paquet(elytres, air(-0.05));
|
||||
// Et même gelé en l'air une demi-seconde (ancien scénario), le compteur repart de zéro : pas de point.
|
||||
double total = 0;
|
||||
for (int i = 0; i < 10; i++) total += points(paquet(EtatJoueur.normal(), air(0)), Controle.VOL);
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_C5_C4_escaladeEnPlusDUneSecondeEtExpulsionUnique() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
int premierPointTick = -1, setbacks = 0, expulsionTick = -1;
|
||||
double dyPlane = 0;
|
||||
boolean gele = false;
|
||||
for (int n = 0; n < 200 && expulsionTick < 0; n++) {
|
||||
EtatMouvement m;
|
||||
if (gele) {
|
||||
m = air(0);
|
||||
} else {
|
||||
dyPlane -= 0.02;
|
||||
m = air(dyPlane);
|
||||
}
|
||||
List<Verdict> vs = paquet(EtatJoueur.normal(), m);
|
||||
for (int n = 0; n < 2000 && expulsionTick < 0; n++) {
|
||||
List<Verdict> vs = paquet(EtatJoueur.normal(), plane());
|
||||
if (points(vs, Controle.VOL) > 0 && premierPointTick < 0) premierPointTick = tick;
|
||||
Sanction s = Verdict.pire(vs);
|
||||
if (s == Sanction.SETBACK) {
|
||||
setbacks++;
|
||||
gele = true;
|
||||
tick++; // teleport() : le paquet suivant n'est pas mesuré (Garde.teleportVanilla)
|
||||
y = yRetour;
|
||||
setback();
|
||||
paquet(EtatJoueur.normal(), sol()); // de retour au sol, le tricheur recommence
|
||||
} else if (s == Sanction.EXPULSION) {
|
||||
expulsionTick = tick;
|
||||
}
|
||||
}
|
||||
assertTrue(expulsionTick > 0, "expulsion atteinte");
|
||||
assertTrue(expulsionTick > 0, "un tricheur obstiné finit expulsé");
|
||||
int duree = expulsionTick - premierPointTick;
|
||||
Mesures.noter("C5 premier point -> expulsion : " + duree + " ticks (" + duree * 50 + " ms), " + setbacks
|
||||
+ " setbacks (journal reel : 5 setbacks, expulsion a la 1re seconde)");
|
||||
assertTrue(duree < 20, "moins d'une seconde entre le premier point et l'expulsion : " + duree + " ticks");
|
||||
assertTrue(setbacks >= 3 && setbacks <= 6, "quelques setbacks seulement : " + setbacks);
|
||||
Mesures.noter("C5 corrige : premier point -> expulsion : " + duree + " ticks (" + duree * 50 + " ms), "
|
||||
+ setbacks + " setbacks");
|
||||
assertTrue(duree >= 40, "au moins 2 s entre le premier point et l'expulsion : " + duree + " ticks");
|
||||
assertEquals(cfg.setbacksAvantExpulsion, setbacks, "l'expulsion vient après plusieurs setbacks distincts");
|
||||
|
||||
// C4 (partie moteur) : rien ne retient « déjà expulsé » ; chaque paquet suivant redonne une EXPULSION.
|
||||
int expulsionsSuivantes = 0;
|
||||
for (int i = 0; i < 20; i++) {
|
||||
if (Verdict.pire(paquet(EtatJoueur.normal(), air(0))) == Sanction.EXPULSION) expulsionsSuivantes++;
|
||||
}
|
||||
assertEquals(20, expulsionsSuivantes, "chaque paquet après l'expulsion rend encore EXPULSION");
|
||||
// C4 : l'expulsion est à usage unique ; le moteur ne rend plus rien pour ce joueur.
|
||||
assertTrue(moteur.expulser(joueur, tick * 50L), "première expulsion acceptée");
|
||||
assertFalse(moteur.expulser(joueur, tick * 50L), "deuxième demande refusée");
|
||||
int verdictsSuivants = 0;
|
||||
for (int i = 0; i < 20; i++) verdictsSuivants += paquet(EtatJoueur.normal(), plane()).size();
|
||||
assertEquals(0, verdictsSuivants, "aucun verdict après l'expulsion");
|
||||
// C6 : même si l'état du joueur est retiré pendant disconnect(), la marque d'expulsion reste.
|
||||
moteur.retirer(joueur);
|
||||
assertFalse(moteur.expulser(joueur, tick * 50L));
|
||||
moteur.oublierExpulsion(joueur); // reconnexion
|
||||
assertTrue(moteur.expulser(joueur, tick * 50L));
|
||||
}
|
||||
|
||||
@Test
|
||||
void jamaisDeBannissement() {
|
||||
for (Sanction s : Sanction.values()) assertFalse(s.name().contains("BAN"), "sanction " + s);
|
||||
}
|
||||
|
||||
@Test
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur