Comparer les révisions
6
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
d9530d0661 | |||
|
|
9335654541 | |||
|
|
56a98f3a5c | |||
|
|
44504eca0c | |||
|
|
bbb08a95f8 | |||
|
|
bfc8f5719c | |||
Aucun fichier ne correspond à votre recherche
@@ -0,0 +1,41 @@
|
||||
#!/bin/sh
|
||||
# Autotests GastinelGarde (16/10/2026) : compile et lance les tests dans un conteneur JDK 21 jetable.
|
||||
# Usage (sur cornafserver) : sh ~/staging/garde-cas-limites-1016/autotests.sh
|
||||
# Entrée : ~/staging/garde-cas-limites-1016/garde.tgz (copie du worktree test/cas-limites, sans .git ni build).
|
||||
# Ne touche ni à ~/server-infra ni au conteneur minecraft-neoforge.
|
||||
set -e
|
||||
D="$HOME/staging/garde-cas-limites-1016"
|
||||
cd "$D"
|
||||
rm -rf src-build
|
||||
mkdir src-build
|
||||
tar xzf garde.tgz -C src-build
|
||||
cd src-build
|
||||
sed -i 's/\r$//' gradlew
|
||||
mkdir -p "$HOME/.cache/gastinelclaims-gradle"
|
||||
set +e
|
||||
nice -n 10 docker run --rm --memory 4g --cpus 4 \
|
||||
-u "$(id -u):$(id -g)" \
|
||||
-e GRADLE_USER_HOME=/gradle-home \
|
||||
-v "$HOME/.cache/gastinelclaims-gradle:/gradle-home" \
|
||||
-v "$(pwd):/src" -w /src \
|
||||
eclipse-temurin:21-jdk \
|
||||
sh ./gradlew --no-daemon clean test > "$D/build.log" 2>&1
|
||||
CODE=$?
|
||||
set -e
|
||||
echo "code de sortie gradle : $CODE"
|
||||
grep -E "FAILED|BUILD|error:|tests completed" "$D/build.log" | head -40
|
||||
echo "--- totaux (XML JUnit) ---"
|
||||
T=0; F=0; E=0; S=0
|
||||
for x in build/test-results/test/*.xml; do
|
||||
[ -f "$x" ] || continue
|
||||
l=$(grep -o '<testsuite [^>]*>' "$x" | head -1)
|
||||
t=$(echo "$l" | sed -n 's/.* tests="\([0-9]*\)".*/\1/p'); f=$(echo "$l" | sed -n 's/.* failures="\([0-9]*\)".*/\1/p')
|
||||
e=$(echo "$l" | sed -n 's/.* errors="\([0-9]*\)".*/\1/p'); s=$(echo "$l" | sed -n 's/.* skipped="\([0-9]*\)".*/\1/p')
|
||||
T=$((T+t)); F=$((F+f)); E=$((E+e)); S=$((S+s))
|
||||
case "$x" in *Autotest*) echo "$(basename "$x") tests=$t echecs=$f erreurs=$e ignores=$s";; esac
|
||||
done
|
||||
echo "TOTAL tests=$T echecs=$F erreurs=$E ignores=$S"
|
||||
echo "--- mesures ---"
|
||||
cat build/minecraft-junit/build/autotests-mesures.txt build/autotests-mesures.txt 2>/dev/null || true
|
||||
echo "--- echecs detailles ---"
|
||||
for x in build/test-results/test/*.xml; do grep -A6 '<failure' "$x" 2>/dev/null | head -30; done | head -120
|
||||
@@ -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;
|
||||
|
||||
@@ -0,0 +1,64 @@
|
||||
package com.gastinelgarde;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.Map;
|
||||
import net.minecraft.world.entity.Entity;
|
||||
import net.minecraft.world.entity.EntityType;
|
||||
import net.minecraft.world.entity.Marker;
|
||||
import org.junit.jupiter.api.Assumptions;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* Autotests du 16/10/2026, nuit : contournement n°3 de la revue de sécurité (table SUIVIES pleine).
|
||||
*
|
||||
* Garde.boitesVues n'ajoute une cible non joueur à la table que si elle compte moins de SUIVIES_MAX entrées ; sinon
|
||||
* elle renvoie null (pas de mesure) et ne la suivra jamais tant que la table reste pleine. La table est commune à
|
||||
* tout le serveur, les joueurs connectés y comptent aussi (sans plafond), une entrée vit 10 s après le dernier coup.
|
||||
*
|
||||
* Le test remplit la table par réflexion avec des identifiants négatifs (jamais attribués) et frappe une entité
|
||||
* « marker » construite sans monde. Si l'environnement de test ne permet pas de construire l'entité, le test est
|
||||
* ignoré (assumption) au lieu d'échouer.
|
||||
*/
|
||||
class AutotestSuiviesTest {
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Test
|
||||
void FAILLE_revue3_tablePleineLesNouvellesCiblesNeSontJamaisSuivies() throws Exception {
|
||||
Field fTable = Garde.class.getDeclaredField("SUIVIES");
|
||||
fTable.setAccessible(true);
|
||||
Map<Integer, Object> table = (Map<Integer, Object>) fTable.get(null);
|
||||
Field fMax = Garde.class.getDeclaredField("SUIVIES_MAX");
|
||||
fMax.setAccessible(true);
|
||||
int max = fMax.getInt(null);
|
||||
assertEquals(256, max);
|
||||
|
||||
Entity cible;
|
||||
try {
|
||||
cible = new Marker(EntityType.MARKER, null);
|
||||
} catch (Throwable t) {
|
||||
Assumptions.abort("entité impossible à construire hors jeu : " + t);
|
||||
return;
|
||||
}
|
||||
table.clear();
|
||||
try {
|
||||
// Témoin : table vide, la cible frappée entre dans la table (mesurée au coup suivant).
|
||||
assertNull(Garde.boitesVues(cible, null, 1000), "premier coup : historique incomplet");
|
||||
assertTrue(table.containsKey(cible.getId()), "témoin : la cible est suivie");
|
||||
|
||||
table.clear();
|
||||
for (int i = 0; i < max; i++) table.put(-1 - i, null);
|
||||
for (int k = 0; k < 5; k++) {
|
||||
assertNull(Garde.boitesVues(cible, null, 1000 + 20 * k), "coup " + k + " non mesuré");
|
||||
}
|
||||
assertFalse(table.containsKey(cible.getId()), "prouvé : table pleine, la cible n'est jamais suivie");
|
||||
assertEquals(max, table.size(), "aucune éviction");
|
||||
} finally {
|
||||
table.clear();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,363 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* Autotests du 16/10/2026, nuit : cas limites d'un joueur HONNÊTE (fins d'élytres, bords de blocs, échelles, eau,
|
||||
* slime, miel, montures, téléportations, Create / Aeronautics, riptide, lag).
|
||||
*
|
||||
* Un test {@code honnete_…} vérifie qu'aucun point n'est donné. Un test {@code FAUX_POSITIF_…} montre un cas honnête
|
||||
* (ou plausible, à confirmer en jeu) qui est puni aujourd'hui : il passe tant que le défaut existe.
|
||||
*
|
||||
* Les drapeaux « milieu spécial », « au sol serveur », exemptions… sont calculés par l'adaptateur (Garde.java) à partir
|
||||
* du monde : ici on suppose qu'il les calcule bien. Ce qui dépend de la détection elle-même (bloc de miel trouvé,
|
||||
* contraption vue) n'est pas testable hors jeu.
|
||||
*/
|
||||
class AutotestCasLimitesTest {
|
||||
|
||||
private GardeConfig cfg;
|
||||
private Moteur moteur;
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
private long tick;
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
cfg = new GardeConfig();
|
||||
cfg.mode(Controle.VOL, Mode.ENFORCE);
|
||||
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||
cfg.mode(Controle.NO_FALL, Mode.OBSERVE);
|
||||
moteur = new Moteur(cfg);
|
||||
tick = 5000;
|
||||
}
|
||||
|
||||
private static EtatMouvement m(double dxz, double dy, int ticks, boolean sol, boolean milieu) {
|
||||
return new EtatMouvement(dxz, dy, ticks, sol, sol, false, false, false, 0, 0, milieu, false);
|
||||
}
|
||||
|
||||
private static EtatMouvement air(double dy) {
|
||||
return m(0.1, dy, 1, false, false);
|
||||
}
|
||||
|
||||
private static EtatMouvement sol() {
|
||||
return m(0.1, 0, 1, true, false);
|
||||
}
|
||||
|
||||
private static double points(List<Verdict> vs, Controle c) {
|
||||
double p = 0;
|
||||
for (Verdict v : vs) if (v.controle() == c) p += v.points();
|
||||
return p;
|
||||
}
|
||||
|
||||
private double paquet(EtatJoueur e, EtatMouvement mv) {
|
||||
tick += Math.max(1, mv.ticks());
|
||||
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, e, mv);
|
||||
return points(vs, Controle.VOL) + points(vs, Controle.NO_FALL) + points(vs, Controle.VITESSE);
|
||||
}
|
||||
|
||||
/** Chute vanilla depuis la vitesse v, n ticks. */
|
||||
private double chute(EtatJoueur e, double v, int n) {
|
||||
double total = 0;
|
||||
for (int i = 0; i < n; i++) {
|
||||
total += paquet(e, air(v));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
private void auSol(int n) {
|
||||
for (int i = 0; i < n; i++) paquet(EtatJoueur.normal(), sol());
|
||||
}
|
||||
|
||||
// --- Élytres -----------------------------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void honnete_atterrissageEnElytresPuisMarche() {
|
||||
auSol(3);
|
||||
EtatJoueur el = EtatJoueur.builder().elytres(true).build();
|
||||
double total = 0;
|
||||
for (int i = 0; i < 100; i++) total += paquet(el, m(1.2, -0.4, 1, false, false));
|
||||
total += paquet(el, m(0.8, -0.3, 1, true, false)); // touche le sol, drapeau encore là
|
||||
for (int i = 0; i < 20; i++) total += paquet(EtatJoueur.normal(), sol());
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_finDElytresVitesseHorizontaleQuiDecroit() {
|
||||
cfg.mode(Controle.VITESSE, Mode.OBSERVE);
|
||||
auSol(3);
|
||||
EtatJoueur el = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 40; i++) paquet(el, m(1.5, -0.3, 1, false, false));
|
||||
double total = 0, dxz = 1.5, v = -0.3;
|
||||
for (int i = 0; i < 40; i++) { // drapeau tombé, le joueur tombe vraiment : traînée 0,91 et gravité
|
||||
dxz *= VitesseHorizontale.TRAINEE_AIR;
|
||||
total += paquet(EtatJoueur.normal(), m(dxz, v, 1, false, false));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_finDElytresPlaneQuiContinueCoteClientPuniAussiParVitesse() {
|
||||
cfg.mode(Controle.VOL, Mode.OFF);
|
||||
cfg.mode(Controle.VITESSE, Mode.OBSERVE);
|
||||
auSol(3);
|
||||
EtatJoueur el = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 40; i++) paquet(el, m(1.0, -0.1, 1, false, false));
|
||||
double total = 0;
|
||||
for (int i = 0; i < 20; i++) total += paquet(EtatJoueur.normal(), m(1.0, -0.1, 1, false, false));
|
||||
// Même famille que C1 et que l'alerte vitesse de totoche10 du 15/10 : l'élan hérité ne couvre que 3 ticks.
|
||||
assertTrue(total > 0, "plané continu après la chute du drapeau : puni par vitesse");
|
||||
}
|
||||
|
||||
// --- Bords de blocs ----------------------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void honnete_glissadeAuBordDUnBlocLaTrancheBalayeeTrouveLeBloc() {
|
||||
// Bloc plein x dans [9 ; 10]. Avant : boîte [9,5 ; 10,1] (sur le bloc). Après un pas de 0,6 : [10,1 ; 10,7].
|
||||
double[] t = NoFall.trancheBalayee(10.1, 64.0, 0.2, 10.7, 0.8, 0.6, 0);
|
||||
assertTrue(t[0] < 10.0 && t[3] > 9.0, "la tranche couvre encore le bloc");
|
||||
assertEquals(63.95, t[1], 1e-9);
|
||||
// Avec le bloc trouvé, « au sol serveur » est vrai : aucun point no-fall.
|
||||
assertEquals(0, NoFall.points(m(0.6, -0.5, 1, true, true)), 1e-9);
|
||||
// Sans la tranche (ancien calcul), le même paquet donnait 0,5 point.
|
||||
assertEquals(0.5, NoFall.points(new EtatMouvement(0.6, -0.5, 1, true, false, false, false, false, 0, 0,
|
||||
false, false)), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_tomberDUnBordEtSautSousUnPlafond() {
|
||||
auSol(3);
|
||||
double total = chute(EtatJoueur.normal(), -0.0784, 30); // marche au-delà du bord
|
||||
auSol(3);
|
||||
// Saut sous un plafond à 1,25 bloc : +0,42, puis tête cognée (vitesse remise à 0), puis gravité.
|
||||
total += paquet(EtatJoueur.normal(), air(0.42));
|
||||
total += paquet(EtatJoueur.normal(), air(0.05));
|
||||
total += chute(EtatJoueur.normal(), (0 - VolVertical.GRAVITE) * VolVertical.TRAINEE, 6);
|
||||
auSol(3);
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
// --- Échelles, eau, slime, miel ------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void honnete_echelleMonteeArretAccroupiEtSortieEnHaut() {
|
||||
auSol(3);
|
||||
double total = 0;
|
||||
for (int i = 0; i < 40; i++) total += paquet(EtatJoueur.normal(), m(0, 0.2, 1, false, true));
|
||||
for (int i = 0; i < 40; i++) total += paquet(EtatJoueur.normal(), m(0, 0, 1, false, true)); // accroupi
|
||||
total += chute(EtatJoueur.normal(), (0.2 - VolVertical.GRAVITE) * VolVertical.TRAINEE, 15); // lâche en haut
|
||||
auSol(3);
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_nageEtSortieDeLEauAvecImpulsion() {
|
||||
auSol(3);
|
||||
double total = 0;
|
||||
for (int i = 0; i < 40; i++) total += paquet(EtatJoueur.normal(), m(0.1, 0.1, 1, false, true));
|
||||
// Sortie : impulsion de 0,3 (jumpOutOfFluid) au tick où l'eau n'est plus vue [À VÉRIFIER en jeu].
|
||||
total += chute(EtatJoueur.normal(), 0.3, 20);
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_rebondsSurSlime() {
|
||||
auSol(3);
|
||||
double total = chute(EtatJoueur.normal(), -0.0784, 25); // chute de ~10 blocs
|
||||
double v = 1.0;
|
||||
for (int r = 0; r < 4; r++) {
|
||||
total += paquet(EtatJoueur.normal(), m(0.1, 0, 1, true, true)); // contact slime
|
||||
total += chute(EtatJoueur.normal(), v, 30);
|
||||
v *= 0.8;
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_glissadeLeLongDUnBlocDeMielPuisChute() {
|
||||
auSol(3);
|
||||
double total = chute(EtatJoueur.normal(), 0.42, 3);
|
||||
for (int i = 0; i < 80; i++) total += paquet(EtatJoueur.normal(), m(0, -0.05, 1, false, true));
|
||||
total += chute(EtatJoueur.normal(), (-0.05 - VolVertical.GRAVITE) * VolVertical.TRAINEE, 10);
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_mielNonDetecteLaGlissadeEstPriseCommeUnPlane() {
|
||||
// Si l'adaptateur ne voit pas le miel (bloc à plus de 0,1 bloc de la boîte, bloc de mod collant…), la descente
|
||||
// à -0,05 bloc/tick est un plané : la détection elle-même n'est pas testable hors jeu.
|
||||
auSol(3);
|
||||
double total = chute(EtatJoueur.normal(), 0.42, 3);
|
||||
for (int i = 0; i < 30; i++) total += paquet(EtatJoueur.normal(), air(-0.05));
|
||||
assertTrue(total > 0);
|
||||
}
|
||||
|
||||
// --- Montures et véhicules -------------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void honnete_descendreDeChevalEnPleinSaut() {
|
||||
auSol(3);
|
||||
EtatJoueur monte = EtatJoueur.builder().enVehicule(true).build();
|
||||
double total = 0;
|
||||
for (int i = 0; i < 10; i++) total += paquet(monte, air(0.3));
|
||||
total += chute(EtatJoueur.normal(), 0.1, 25);
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_sautDeChevalEtBateauQuiTombeDUneFalaise() {
|
||||
UUID j = UUID.randomUUID();
|
||||
double total = 0;
|
||||
double v = 0.9;
|
||||
for (int i = 0; i < 30; i++) { // saut de cheval (force 0,9) : ~25 ticks en l'air
|
||||
EtatVehicule e = new EtatVehicule(EtatVehicule.Type.MONTURE, 0.5, v, 1, false, false, false, 0.3, false);
|
||||
total += points(moteur.vehicule(j, (100 + i) * 50L, EtatJoueur.normal(), e), Controle.VEHICULE_VOL);
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
moteur.nouveauVehicule(j);
|
||||
v = 0;
|
||||
for (int i = 0; i < 80; i++) { // bateau : -0,04 par tick, sans traînée verticale
|
||||
v -= 0.04;
|
||||
EtatVehicule e = new EtatVehicule(EtatVehicule.Type.BATEAU, 0.3, v, 1, false, false, false, 0, false);
|
||||
total += points(moteur.vehicule(j, (200 + i) * 50L, EtatJoueur.normal(), e), Controle.VEHICULE_VOL);
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
// --- Téléportations ----------------------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void honnete_teleportationEnLAirPuisChute() {
|
||||
auSol(3);
|
||||
double total = 0;
|
||||
for (int t = 0; t <= cfg.graceTeleportTicks; t++) {
|
||||
total += paquet(EtatJoueur.builder().ticksDepuisTeleport(t).build(), air(-0.0784 * Math.min(t, 5)));
|
||||
}
|
||||
total += chute(EtatJoueur.normal(), -0.5, 40);
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_teleportationLenteLeJoueurResteFigeApresLaGrace() {
|
||||
// /rtp, /tpa vers des tronçons non chargés : si le client reste figé (dy = 0) plus de 2 s après la
|
||||
// téléportation, la grâce (40 ticks) est finie et l'immobilité en l'air est un plané [À VÉRIFIER en jeu].
|
||||
auSol(3);
|
||||
double total = 0;
|
||||
for (int t = 0; t <= cfg.graceTeleportTicks; t++) {
|
||||
total += paquet(EtatJoueur.builder().ticksDepuisTeleport(t).build(), air(0));
|
||||
}
|
||||
assertEquals(0, total, 1e-9, "pendant la grâce : rien");
|
||||
for (int i = 0; i < 20; i++) total += paquet(EtatJoueur.normal(), air(0));
|
||||
assertTrue(total > 0, "figé 1 s de plus après la grâce : puni");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C2_reapparitionPendantUnSetbackNonOuverte() {
|
||||
// Rappel : GraceTeleport n'ouvre pas de grâce pour SETBACK ni pour un renvoi de SETBACK.
|
||||
GraceTeleport g = new GraceTeleport();
|
||||
g.annoncer(GraceTeleport.Origine.SETBACK);
|
||||
assertFalse(g.teleport());
|
||||
g.annoncer(GraceTeleport.Origine.RENVOI);
|
||||
assertFalse(g.teleport(), "renvoi d'un setback non confirmé : pas de grâce non plus");
|
||||
assertTrue(g.teleport(), "une téléportation externe ouvre la grâce");
|
||||
}
|
||||
|
||||
// --- Create / Aeronautics -------------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void honnete_surUnVaisseauQuiMontePuisSautEnBas() {
|
||||
auSol(3);
|
||||
EtatJoueur poche = EtatJoueur.builder().pocheContraption(true).build();
|
||||
double total = 0;
|
||||
for (int i = 0; i < 200; i++) total += paquet(poche, air(0.1)); // le pont monte, le serveur n'y voit pas de sol
|
||||
total += chute(EtatJoueur.normal(), 0.1, 40);
|
||||
assertEquals(0, total, 1e-9);
|
||||
assertTrue(DetectionContraption.dansLaGrace(140, 100, 40));
|
||||
assertFalse(DetectionContraption.dansLaGrace(141, 100, 40));
|
||||
assertFalse(DetectionContraption.dansLaGrace(90, 100, 40), "horloge revenue en arrière : pas de grâce");
|
||||
// Véhicule de mod (dirigeable, train Create) : jamais contrôlé en vol.
|
||||
EtatVehicule dirigeable = new EtatVehicule(EtatVehicule.Type.AUTRE, 0.5, 0.0, 1, false, false, false, 0, false);
|
||||
for (int i = 0; i < 100; i++) {
|
||||
assertEquals(0, points(moteur.vehicule(joueur, (9000 + i) * 50L, EtatJoueur.normal(), dirigeable),
|
||||
Controle.VEHICULE_VOL), 1e-9);
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_vaisseauNonDetecteLeJoueurSurLePontEstPrisPourUnVoleur() {
|
||||
// Dépendance totale à la détection (DetectionContraption / SableAcces), non testable hors jeu : si le pont
|
||||
// d'un grand vaisseau n'est pas vu (distanceContraption trop courte, classe de mod inconnue), punition.
|
||||
auSol(3);
|
||||
double total = 0;
|
||||
for (int i = 0; i < 30; i++) total += paquet(EtatJoueur.normal(), air(0.1));
|
||||
assertTrue(total > 0);
|
||||
}
|
||||
|
||||
// --- Riptide -------------------------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void honnete_vrilleRiptidePuisArcBalistique() {
|
||||
auSol(3);
|
||||
EtatJoueur vrille = EtatJoueur.builder().riptide(true).build();
|
||||
double total = 0;
|
||||
for (int i = 0; i < 20; i++) total += paquet(vrille, m(2.5, 1.5, 1, false, false));
|
||||
total += chute(EtatJoueur.normal(), 1.2, 60);
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
// --- Lag ---------------------------------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* Longue chute (80 paquets, un tick client chacun) reçue avec une gigue réseau régulière : {@code motif} donne
|
||||
* les ticks serveur écoulés avant chaque paquet (ex. 3, 0, 0 : trois paquets arrivés ensemble toutes les 3 ticks).
|
||||
*/
|
||||
private double chuteAvecGigue(int[] motif) {
|
||||
auSol(3);
|
||||
double total = 0, v = 0;
|
||||
for (int p = 0; p < 80; p++) {
|
||||
total += paquet(EtatJoueur.normal(), m(0.1, v, motif[p % motif.length], false, false));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_lagRafalesDeDeuxEtDeCinqPaquets() {
|
||||
assertEquals(0, chuteAvecGigue(new int[] {2, 0}), 1e-9);
|
||||
assertEquals(0, chuteAvecGigue(new int[] {5, 0, 0, 0, 0}), 1e-9);
|
||||
assertEquals(0, chuteAvecGigue(new int[] {4, 0, 0, 0}), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_lagRafalesDeTroisPaquetsPendantUneLongueChute() {
|
||||
// Un paquet d'UN tick client arrivé après 3 ticks serveur n'est comparé qu'à 2 ou 3 ticks de gravité, et la
|
||||
// vitesse retenue est alors dy / 3 : le paquet suivant est faux aussi. Motif 3, 0, 0 : +1 anomalie par rafale,
|
||||
// premier point après ~31 paquets (1,5 s de chute, ~12 blocs). Simulé, à confirmer avec une trace réelle.
|
||||
double total = chuteAvecGigue(new int[] {3, 0, 0});
|
||||
assertTrue(total > 0);
|
||||
Mesures.noter("Lag 3,0,0 : " + total + " points de vol sur une chute de 80 paquets");
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_gelDuServeurDeTroisSecondesEnPleineChute() {
|
||||
auSol(3);
|
||||
double total = chute(EtatJoueur.normal(), 0.42, 8);
|
||||
total += paquet(EtatJoueur.normal(), m(0.1, -12.0, 60, false, false)); // 60 ticks : vitesse oubliée
|
||||
total += chute(EtatJoueur.normal(), -2.5, 20);
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_tpsBasLeVolNUtilisePasLeFacteurDeLagMaisLaChuteResteJuste() {
|
||||
EtatJoueur lent = EtatJoueur.builder().tps(12).build();
|
||||
auSol(3);
|
||||
assertEquals(0, chute(lent, 0.42, 60), 1e-9);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,259 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* Autotests du 16/10/2026, nuit : contournements signalés par la revue de sécurité automatique des commits 7a5a1c9 /
|
||||
* 937d43d (contrôle coups-hors-boite) et constats C13, C15 de l'autocritique.
|
||||
*
|
||||
* Un test {@code FAILLE_…} passe tant que le contournement marche ; il échouera quand il sera corrigé (inverser
|
||||
* alors l'assertion). Chaque faille a un test « témoin » qui montre que, sans le contournement, la triche est vue.
|
||||
* Le contournement n°3 (table SUIVIES pleine) dépend de Minecraft : voir {@code com.gastinelgarde.AutotestSuiviesTest}.
|
||||
*/
|
||||
class AutotestContournementsTest {
|
||||
|
||||
private static final double V = 0.28; // cible qui sprinte, blocs/tick
|
||||
private GardeConfig cfg;
|
||||
private Moteur moteur;
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
cfg = new GardeConfig();
|
||||
moteur = new Moteur(cfg);
|
||||
}
|
||||
|
||||
private static double[] boite(double x) {
|
||||
return new double[] {x - 0.3, 0, -0.3, x + 0.3, 1.8, 0.3};
|
||||
}
|
||||
|
||||
/** Boîtes vues : cible qui avance de V par tick en x, arrivée en xNow (comme Garde92Test). */
|
||||
private static double[][] vues(double xNow, int fenetre) {
|
||||
double[][] b = new double[fenetre + 2][];
|
||||
for (int i = 0; i < b.length; i++) b[i] = boite(xNow - V * (b.length - 1 - i));
|
||||
return b;
|
||||
}
|
||||
|
||||
private static double[] vers(double[] de, double x, double y, double z) {
|
||||
return new double[] {x - de[0], y - de[1], z - de[2]};
|
||||
}
|
||||
|
||||
private static double points(List<Verdict> vs, Controle c) {
|
||||
double p = 0;
|
||||
for (Verdict v : vs) if (v.controle() == c) p += v.points();
|
||||
return p;
|
||||
}
|
||||
|
||||
/** Coup mesuré par coups-hors-boite, puis paquet de mouvement suivant (œil et regard « suivants »). */
|
||||
private List<Verdict> coup(long t, EtatJoueur etat, double[] oeil, double[] regard, double[] oeilSuivant,
|
||||
double[] regardSuivant, double xCible, double[][] vues) {
|
||||
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, t, etat, oeil, regard, boite(xCible), 3.0,
|
||||
V, true, false, oeil, vues));
|
||||
vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeilSuivant, regardSuivant));
|
||||
return vs;
|
||||
}
|
||||
|
||||
// --- Revue n°1 : ping gonflé au-delà de seriePingMaxMs = coup exempté -----------------------------------------
|
||||
|
||||
private double serieHitboxAvecPing(int ping) {
|
||||
moteur = new Moteur(cfg);
|
||||
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
|
||||
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg);
|
||||
double total = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
double x = 5 * k;
|
||||
double[] oeil = {x, 1.62, -3.0};
|
||||
double[] regard = vers(oeil, x + 0.75, 1.2, 0); // client « hitbox » : 0,45 bloc devant la cible
|
||||
total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)),
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_revue1_pingDeclareAuDessusDe500msExempteTotalementLesCoups() {
|
||||
assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs) > 0, "témoin : à 500 ms, la série est vue");
|
||||
assertEquals(0, serieHitboxAvecPing(cfg.seriePingMaxMs + 1), 1e-9,
|
||||
"prouvé : à 501 ms (ping falsifiable, F07), aucun coup n'est mesuré");
|
||||
}
|
||||
|
||||
// --- Revue n°2 / C13 : regard et œil du paquet SUIVANT acceptés sans borne --------------------------------------
|
||||
|
||||
@Test
|
||||
void FAILLE_revue2_regardSuivantRameneSurLaCibleEffaceLeCoupHorsBoite() {
|
||||
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||
double temoin = 0, triche = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
double x = 5 * k;
|
||||
double[] oeil = {x, 1.62, -3.0};
|
||||
double[] hors = {0, 0, -1}; // regard tourné à 180° de la cible au moment du coup
|
||||
double[] surCible = vers(oeil, x, 1.2, 0);
|
||||
triche += points(coup(k * 600L, EtatJoueur.normal(), oeil, hors, oeil, surCible, x, vues(x, fenetre)),
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
moteur = new Moteur(cfg);
|
||||
for (int k = 0; k < 10; k++) {
|
||||
double x = 5 * k;
|
||||
double[] oeil = {x, 1.62, -3.0};
|
||||
double[] hors = {0, 0, -1};
|
||||
temoin += points(coup(k * 600L, EtatJoueur.normal(), oeil, hors, oeil, hors, x, vues(x, fenetre)),
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
assertTrue(temoin > 0, "témoin : le même regard gardé au paquet suivant est vu");
|
||||
assertEquals(0, triche, 1e-9, "prouvé : un demi-tour du regard au paquet suivant efface tout (aucune borne d'angle)");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_revue2_oeilSuivantAvanceDe09BlocEffaceLaPorteeAllongee() {
|
||||
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||
double temoin = 0, triche = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
double x = 5 * k;
|
||||
double[] loin = {x, 1.62, -3.9}; // 3,6 blocs de la boîte : reach
|
||||
double[] proche = {x, 1.62, -3.0}; // 0,9 bloc plus près au paquet suivant (sprint : 0,28 bloc/tick)
|
||||
double[] regard = vers(loin, x, 1.2, 0);
|
||||
triche += points(coup(k * 600L, EtatJoueur.normal(), loin, regard, proche, vers(proche, x, 1.2, 0), x,
|
||||
vues(x, fenetre)), Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
moteur = new Moteur(cfg);
|
||||
for (int k = 0; k < 10; k++) {
|
||||
double x = 5 * k;
|
||||
double[] loin = {x, 1.62, -3.9};
|
||||
double[] regard = vers(loin, x, 1.2, 0);
|
||||
temoin += points(coup(k * 600L, EtatJoueur.normal(), loin, regard, loin, regard, x, vues(x, fenetre)),
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
assertTrue(temoin > 0);
|
||||
assertEquals(0, triche, 1e-9, "prouvé : l'œil suivant n'est pas borné à un déplacement légal");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C13_porteeEtHitboxGardentLeMinimumAvecLePaquetSuivant() {
|
||||
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
|
||||
double[] b = boite(0);
|
||||
double[] loin = {0, 1.62, -4.3}; // 4,0 blocs de la boîte : refus vanilla à la limite
|
||||
double[] proche = {0, 1.62, -3.5}; // 3,2 blocs au paquet suivant
|
||||
double[] regard = vers(loin, 0, 1.0, 0);
|
||||
// Témoin : paquet suivant identique.
|
||||
List<Verdict> t = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0,
|
||||
true, false));
|
||||
t.addAll(moteur.regardPorteeHitbox(joueur, 50, loin, regard));
|
||||
assertTrue(points(t, Controle.PORTEE) > 0, "témoin : 4,0 blocs sur cible immobile est vu");
|
||||
|
||||
moteur = new Moteur(cfg);
|
||||
List<Verdict> v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0,
|
||||
true, false));
|
||||
v.addAll(moteur.regardPorteeHitbox(joueur, 50, proche, vers(proche, 0, 1.0, 0)));
|
||||
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "prouvé : s'avancer au paquet suivant efface la portée");
|
||||
|
||||
// Angle killaura : regard à 180° au coup, sur la cible au paquet suivant.
|
||||
cfg.mode(Controle.PORTEE, Mode.OFF);
|
||||
cfg.mode(Controle.HITBOX, Mode.OFF);
|
||||
moteur = new Moteur(cfg);
|
||||
double[] oeil = {0, 1.62, -2.5};
|
||||
List<Verdict> a = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil, new double[] {0, 0, -1},
|
||||
b, 3.0, 0, false, true));
|
||||
a.addAll(moteur.regardPorteeHitbox(joueur, 50, oeil, vers(oeil, 0, 1.0, 0)));
|
||||
assertEquals(0, points(a, Controle.KILLAURA_ANGLE), 1e-9, "prouvé : rotation silencieuse effacée");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee() {
|
||||
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
|
||||
double[] b = boite(0);
|
||||
double[] oeil33 = {0, 1.62, -3.59}; // 3,29 blocs
|
||||
List<Verdict> v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil33,
|
||||
vers(oeil33, 0, 1.0, 0), b, 3.0, 0, true, false));
|
||||
v.addAll(moteur.terminerCoup(joueur));
|
||||
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,29 blocs sur cible immobile : rien");
|
||||
|
||||
moteur = new Moteur(cfg);
|
||||
double[] oeil40 = {0, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte
|
||||
v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil40, vers(oeil40, 0, 1.0, 0), b, 3.0,
|
||||
V, true, false));
|
||||
v.addAll(moteur.terminerCoup(joueur));
|
||||
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,99 blocs sur cible qui sprinte : rien pour portee");
|
||||
}
|
||||
|
||||
// --- Revue n°4 : la fenêtre d'historique grandit avec le ping déclaré ------------------------------------------
|
||||
|
||||
private double serieDerriereLaCible(int ping) {
|
||||
moteur = new Moteur(cfg);
|
||||
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
|
||||
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg); // ce que Garde.boitesVues calcule depuis latency()
|
||||
double total = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
double x = 10 * k;
|
||||
double[] oeil = {x - 1.5, 1.62, -2.5};
|
||||
// Client « hitbox » : touche 3,3 blocs DERRIÈRE le centre de la cible (là où elle était il y a ~12 ticks).
|
||||
double[] regard = vers(oeil, x - 3.6, 1.2, 0);
|
||||
total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)),
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_revue4_pingDeclareA450msElargitLaFenetreEtCacheLaTriche() {
|
||||
assertEquals(8, PorteeHitbox.ticksFenetre(30, cfg));
|
||||
assertEquals(16, PorteeHitbox.ticksFenetre(450, cfg));
|
||||
assertEquals(17, PorteeHitbox.ticksFenetre(500, cfg));
|
||||
assertTrue(serieDerriereLaCible(30) > 0, "témoin : à 30 ms, la série est vue");
|
||||
assertEquals(0, serieDerriereLaCible(450), 1e-9,
|
||||
"prouvé : le même client qui annonce 450 ms de ping n'est plus vu (fenêtre 16 ticks au lieu de 8)");
|
||||
}
|
||||
|
||||
// --- C15 : vitesse 0,40 en l'air et Timer 1,09 non vus ---------------------------------------------------------
|
||||
|
||||
private static EtatMouvement pas(double dxz, boolean sol) {
|
||||
return new EtatMouvement(dxz, 0, 1, sol, sol, true, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
private double vitesse(double dxzAir, double dxzSol, int cycle, int ticks) {
|
||||
cfg.mode(Controle.VOL, Mode.OFF);
|
||||
cfg.mode(Controle.NO_FALL, Mode.OFF);
|
||||
moteur = new Moteur(cfg);
|
||||
double total = 0;
|
||||
for (int i = 0; i < ticks; i++) {
|
||||
boolean sol = cycle > 0 && i % cycle == 0;
|
||||
total += points(moteur.mouvement(joueur, i * 50L, EtatJoueur.normal(), pas(sol ? dxzSol : dxzAir, sol)),
|
||||
Controle.VITESSE);
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C15_bhopA040BlocParTickNestJamaisVu() {
|
||||
// 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (un sprint-saut honnête fait en moyenne ~0,28 à 0,33).
|
||||
assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C15_speedAuSolA037BlocParTickNestJamaisVu() {
|
||||
assertTrue(vitesse(0.45, 0.45, 1, 200) > 0, "témoin : 0,45 au sol (+50 %) est vu");
|
||||
// 0,37 au sol : +23 % sur le sprint (0,30), l'excès (0,06/tick) reste sous le tampon de 1,5 bloc / 20 ticks.
|
||||
assertEquals(0, vitesse(0.37, 0.37, 1, 400), 1e-9);
|
||||
}
|
||||
|
||||
private double timer(long intervalleMs, int secondes) {
|
||||
moteur = new Moteur(cfg);
|
||||
double total = 0;
|
||||
for (long t = 0; t < secondes * 1000L; t += intervalleMs) {
|
||||
total += points(moteur.paquetMouvement(joueur, 10_000 + t, EtatJoueur.normal()), Controle.TIMER);
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C15_timerA109NestJamaisVu() {
|
||||
assertTrue(timer(40, 10) > 0, "témoin : 25 paquets/s (timer 1,25) est vu");
|
||||
assertEquals(0, timer(46, 30), 1e-9, "prouvé : 21,7 paquets/s (timer 1,09) pendant 30 s, aucun point");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,287 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
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.
|
||||
*
|
||||
* 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
|
||||
* teleport() non mesuré (Garde.teleportVanilla remet mouvementTick à zéro).
|
||||
*/
|
||||
class AutotestVolIncidentTest {
|
||||
|
||||
private static final double Y_SOL = 110.875;
|
||||
|
||||
private GardeConfig cfg;
|
||||
private Moteur moteur;
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
private int tick;
|
||||
private double y;
|
||||
/** Modèle de Garde.apresMouvement : dernière position mémorisée (y) et si elle était au sol serveur. */
|
||||
private double yRetour;
|
||||
private boolean retourAuSol;
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
cfg = new GardeConfig();
|
||||
cfg.mode(Controle.VOL, Mode.ENFORCE); // mode en production le 15/10 (rapport des journaux)
|
||||
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||
cfg.mode(Controle.NO_FALL, Mode.OFF);
|
||||
moteur = new Moteur(cfg);
|
||||
tick = 37_000;
|
||||
y = Y_SOL;
|
||||
yRetour = Y_SOL;
|
||||
retourAuSol = true;
|
||||
}
|
||||
|
||||
static EtatMouvement air(double dy) {
|
||||
return new EtatMouvement(0.1, dy, 1, false, false, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
static EtatMouvement sol() {
|
||||
return new EtatMouvement(0.1, 0, 1, true, true, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
static double points(List<Verdict> vs, Controle c) {
|
||||
double p = 0;
|
||||
for (Verdict v : vs) if (v.controle() == c) p += v.points();
|
||||
return p;
|
||||
}
|
||||
|
||||
/** Un paquet accepté, avec le modèle de mémorisation de la position de retour. */
|
||||
private List<Verdict> paquet(EtatJoueur e, EtatMouvement m) {
|
||||
tick++;
|
||||
y += m.dy();
|
||||
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, e, m);
|
||||
// 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();
|
||||
}
|
||||
return vs;
|
||||
}
|
||||
|
||||
/**
|
||||
* Trace de Rednixxu (rapport des journaux, ticks 37 589 à 37 614) : au sol à y = 110,875, saut, drapeau élytres
|
||||
* pendant 7 ticks, drapeau retombé alors que le client plane encore (accélération ~0,02 bloc/tick² au lieu de 0,08).
|
||||
*
|
||||
* @return verdicts de chaque paquet de plané sans drapeau
|
||||
*/
|
||||
private List<List<Verdict>> sautPuisPlaneSansDrapeau(int ticksPlane) {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double v = 0.42;
|
||||
for (int i = 0; i < 5; i++) { // saut normal
|
||||
paquet(EtatJoueur.normal(), air(v));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 7; i++) paquet(elytres, air(-0.05)); // drapeau 16 : exempté
|
||||
List<List<Verdict>> sortie = new ArrayList<>();
|
||||
for (int k = 1; k <= ticksPlane; k++) sortie.add(paquet(EtatJoueur.normal(), air(-0.02 * k)));
|
||||
return sortie;
|
||||
}
|
||||
|
||||
/** 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 CORRIGE_C1_planeDElytresDontLeDrapeauTombeNEstPlusPrisPourDuVol() {
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
|
||||
double total = 0;
|
||||
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);
|
||||
}
|
||||
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
|
||||
void honnete_finDElytresSuivieDUneVraieChuteNeDonneRien() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 40; i++) paquet(elytres, air(-0.5));
|
||||
double v = -0.5, total = 0;
|
||||
for (int i = 0; i < 60; i++) {
|
||||
total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL);
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
assertEquals(0, total, 1e-9, "réfuté : une fin d'élytres suivie d'une chute vanilla ne donne rien");
|
||||
}
|
||||
|
||||
// --- C3 : point de retour au sol (corrigé le 16/10) --------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
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 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");
|
||||
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 remis à zéro, escalade, expulsion unique (corrigés le 16/10) ---------------------------
|
||||
|
||||
/** 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;
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_C2_apresUnSetbackLeVolEtLesVlRepartentDeZero() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
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++) {
|
||||
List<Verdict> v = paquet(EtatJoueur.normal(), sol());
|
||||
assertEquals(0, points(v, Controle.VOL), 1e-9, "paquet " + i + " après le setback");
|
||||
}
|
||||
// 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;
|
||||
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++;
|
||||
setback();
|
||||
paquet(EtatJoueur.normal(), sol()); // de retour au sol, le tricheur recommence
|
||||
} else if (s == Sanction.EXPULSION) {
|
||||
expulsionTick = tick;
|
||||
}
|
||||
}
|
||||
assertTrue(expulsionTick > 0, "un tricheur obstiné finit expulsé");
|
||||
int duree = expulsionTick - premierPointTick;
|
||||
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 : 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
|
||||
void referenceEnObserveLeMemeIncidentNeToucheJamaisLeJoueur() {
|
||||
cfg.mode(Controle.VOL, Mode.OBSERVE);
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(40);
|
||||
for (List<Verdict> v : vs) {
|
||||
assertNotEquals(Sanction.SETBACK, Verdict.pire(v));
|
||||
assertNotEquals(Sanction.EXPULSION, Verdict.pire(v));
|
||||
}
|
||||
}
|
||||
|
||||
// --- C10 : sauts en l'air espacés --------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void FAILLE_C10_unSautEnLAirTousLesDixTicksMonteSansFinSansAucunPoint() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double total = 0;
|
||||
double depart = y;
|
||||
for (int cycle = 0; cycle < 30; cycle++) {
|
||||
double v = 0.42; // « saut » en plein air
|
||||
for (int i = 0; i < 10; i++) {
|
||||
total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL);
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
}
|
||||
assertEquals(0, total, 1e-9, "prouvé : aucun point");
|
||||
// ~0,5 bloc gagné par cycle de 10 ticks : ~15 blocs en 15 s, sans limite.
|
||||
assertTrue(y - depart > 10, "et le tricheur a gagné " + (y - depart) + " blocs en 15 s");
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT, "C10 : +%.1f blocs en 300 ticks, 0 point", y - depart));
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C10_alternerUnTickAnormalEtUnTickNormalPlaneSansPoint() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double total = 0;
|
||||
double depart = y;
|
||||
for (int i = 0; i < 200; i++) {
|
||||
// tick pair : plané (dy = -0,02, anormal) ; tick impair : la vraie gravité depuis ce plané (normal)
|
||||
double dy = i % 2 == 0 ? -0.02 : (-0.02 - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
total += points(paquet(EtatJoueur.normal(), air(dy)), Controle.VOL);
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
// 200 ticks de chute vanilla depuis l'arrêt : plus de 200 blocs. Ici : ~6 blocs.
|
||||
assertTrue(depart - y < 15, "descente de " + (depart - y) + " blocs en 10 s (chute lente illimitée)");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.StandardOpenOption;
|
||||
|
||||
/**
|
||||
* Autotests du 16/10/2026 : note les valeurs mesurées par les tests (nombre de paquets avant expulsion, altitude du
|
||||
* point de retour…) dans build/autotests-mesures.txt, pour le rapport. N'influence aucun résultat.
|
||||
*/
|
||||
final class Mesures {
|
||||
|
||||
private Mesures() { }
|
||||
|
||||
static void noter(String ligne) {
|
||||
try {
|
||||
Path p = Path.of("build", "autotests-mesures.txt");
|
||||
Files.createDirectories(p.getParent());
|
||||
Files.writeString(p, ligne + System.lineSeparator(), StandardCharsets.UTF_8,
|
||||
StandardOpenOption.CREATE, StandardOpenOption.APPEND);
|
||||
} catch (IOException | RuntimeException ignored) {
|
||||
// mesure facultative
|
||||
}
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur