Comparer les révisions

...
5 Révisions
Auteur SHA1 Message Date

2026-10-16

gastineltetClaude Opus 5.5 44504eca0c GastinelGarde autotests : cas limites d'un joueur honnete
22 tests : fins d'elytres, bords de blocs, plafond, echelles, eau, slime, miel,
montures et bateaux, teleportations, Create / Aeronautics, riptide, lag.
Faux positifs documentes : plane d'elytres puni aussi par vitesse, miel ou
vaisseau non detectes, client fige apres la grace de teleportation, chute
recue en rafales de 3 paquets (gigue reseau). Code de production inchange.
250 tests, 0 echec (cornafserver, conteneur eclipse-temurin:21-jdk).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 01:10:46 +02:00
gastineltetClaude Opus 5.5 bbb08a95f8 GastinelGarde autotests : contournements de la revue de securite, C13, C15
Les 4 contournements de la revue des commits 7a5a1c9 / 937d43d sont prouves :
ping > 500 ms exempte, regard et oeil suivants sans borne, table SUIVIES pleine
sans eviction, fenetre d'historique elargie par le ping declare.
C13 (minimum avec le paquet suivant, reach 3,3 et 4,0 sur cible mobile) et C15
(bhop 0,40, speed sol 0,37, timer 1,09) prouves. Code de production inchange.
228 tests, 0 echec (cornafserver, conteneur eclipse-temurin:21-jdk).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 01:07:49 +02:00
gastineltetClaude Opus 5.5 bfc8f5719c GastinelGarde autotests : incident VOL de Rednixxu (C1 a C5, C10)
Tests qui documentent le comportement actuel sans toucher au code de production :
plane d'elytres sans drapeau puni au 12e tick (C1), point de retour en l'air (C3),
setback sans grace ni remise a zero (C2), 5 setbacks puis expulsion en 850 ms (C5),
expulsion rendue a chaque paquet (C4, partie moteur), sauts en l'air espaces non vus (C10).
218 tests, 0 echec (cornafserver, conteneur eclipse-temurin:21-jdk).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 01:04:25 +02:00
gastineltetClaude Opus 5.5 937d43d499 GastinelGarde #92 : tests du controle coups-hors-boite (cas Rednixxu, faux positifs)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 00:55:32 +02:00
gastineltetClaude Opus 5.5 7a5a1c92c8 GastinelGarde #92 : controle coups-hors-boite (historique des boites des cibles)
Le test hitbox/portee de Rednixxu passait sous portee et hitbox : sur une cible
qui bouge, la marge vitesse x ticks (plafond 1,0 bloc) noyait tout. Nouveau
controle : regard et distance testes contre les boites reellement occupees
par la cible pendant la fenetre d affichage (7 ticks + ping), serie de 4 coups
hors boite sur 10. OBSERVE par defaut.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 00:55:31 +02:00
18 fichiers modifiés avec 1786 ajouts et 4 suppressions

Aucun fichier ne correspond à votre recherche

+41
Voir le fichier
@@ -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
+117
Voir le fichier
@@ -8,6 +8,8 @@ import com.gastinelgarde.core.EtatVehicule;
import com.gastinelgarde.core.GardeConfig;
import com.gastinelgarde.core.GraceRecul;
import com.gastinelgarde.core.GraceTeleport;
import com.gastinelgarde.core.HistoriqueBoites;
import com.gastinelgarde.core.PorteeHitbox;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.RiptideSuivi;
@@ -82,8 +84,31 @@ public final class Garde {
int courantTick = Integer.MIN_VALUE;
int courantVuTick = Integer.MIN_VALUE;
boolean courantProche;
// #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux)
double[] oeilDernier;
double[] oeilAvant;
}
/** #92 : historique des boîtes d'une entité suivie (joueurs, et entités frappées récemment). */
private static final class Suivie {
final Entity entite;
final HistoriqueBoites historique = new HistoriqueBoites();
net.minecraft.world.level.Level niveau;
int jusquaTick;
Suivie(Entity e) {
this.entite = e;
this.niveau = e.level();
}
}
/** Entités dont on garde les boîtes, par identifiant (unique sur le serveur). */
private static final Map<Integer, Suivie> SUIVIES = new HashMap<>();
/** Une entité non joueur frappée est suivie pendant 10 s après le dernier coup. */
private static final int SUIVI_ENTITE_TICKS = 200;
/** Garde-fou mémoire : au plus ce nombre d'entités non joueur suivies. */
private static final int SUIVIES_MAX = 256;
private static final GardeConfig CONFIG = new GardeConfig();
private static final Moteur MOTEUR = new Moteur(CONFIG);
private static final Map<UUID, Marques> MARQUES = new HashMap<>();
@@ -136,6 +161,7 @@ public final class Garde {
traces = null;
}
MARQUES.clear();
SUIVIES.clear();
}
public static synchronized void flushTraces() {
@@ -170,6 +196,8 @@ public final class Garde {
m.teleportTick = p.server.getTickCount();
m.mouvementTick = Integer.MIN_VALUE;
m.vehiculeId = -1;
m.oeilAvant = null;
m.oeilDernier = null;
}
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
@@ -188,6 +216,92 @@ public final class Garde {
if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount();
m.mouvementTick = Integer.MIN_VALUE;
m.vehiculeId = -1;
m.oeilAvant = null;
m.oeilDernier = null;
}
// --- Historique des cibles (#92, contrôle coups-hors-boite) ---
/**
* Début de tick (après les paquets reçus entre deux ticks, avant l'envoi des positions aux clients) : boîte de
* chaque joueur et de chaque entité frappée récemment. C'est ce que les clients vont recevoir pendant ce tick.
* Coût : quelques joueurs et quelques mobs, 6 doubles chacun.
*/
public static void enregistrerHistoriques(MinecraftServer server) {
if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) {
if (!SUIVIES.isEmpty()) SUIVIES.clear();
return;
}
int tick = server.getTickCount();
for (ServerPlayer p : server.getPlayerList().getPlayers()) {
Suivie s = SUIVIES.get(p.getId());
if (s == null || s.entite != p) {
s = new Suivie(p); // connexion, ou réapparition (nouvel objet joueur, même identifiant)
SUIVIES.put(p.getId(), s);
}
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
}
java.util.Iterator<Map.Entry<Integer, Suivie>> it = SUIVIES.entrySet().iterator();
while (it.hasNext()) {
Suivie s = it.next().getValue();
Entity e = s.entite;
if (e.isRemoved() || tick > s.jusquaTick) {
it.remove();
continue;
}
if (e.level() != s.niveau) { // changement de dimension : les anciennes boîtes ne veulent plus rien dire
s.historique.vider();
s.niveau = e.level();
}
net.minecraft.world.phys.AABB b = boiteVisee(e);
s.historique.ajouter(tick, b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ);
}
}
/** Boîte que le client vise (vanilla : boîte gonflée du rayon de visée de l'entité, 0 pour presque toutes). */
static net.minecraft.world.phys.AABB boiteVisee(Entity e) {
float r = e.getPickRadius();
return r > 0 ? e.getBoundingBox().inflate(r) : e.getBoundingBox();
}
/**
* Boîtes de la cible sur la fenêtre où l'attaquant a pu la voir (selon son ping), ou null si l'historique ne
* couvre pas toute la fenêtre (entité jamais frappée jusque-là, connexion récente) : on ne mesure pas.
* Une entité non joueur frappée commence ici à être suivie.
*/
public static double[][] boitesVues(Entity cible, ServerPlayer attaquant, int tick) {
if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return null;
Suivie s = SUIVIES.get(cible.getId());
if (s == null || s.entite != cible) {
if (!(cible instanceof Player) && SUIVIES.size() < SUIVIES_MAX) {
s = new Suivie(cible);
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
SUIVIES.put(cible.getId(), s);
}
return null;
}
if (!(cible instanceof Player)) s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
if (s.niveau != cible.level()) return null;
int fenetre = PorteeHitbox.ticksFenetre(attaquant.connection.latency(), CONFIG);
return s.historique.depuis(tick - fenetre);
}
/** Œil de l'attaquant au paquet de mouvement d'avant le dernier (null si inconnu). */
public static double[] oeilAvant(ServerPlayer p) {
Marques m = MARQUES.get(p.getUUID());
return m == null ? null : m.oeilAvant;
}
/**
* La cible est-elle sur ou près d'une contraption Create / d'un vaisseau Sable ? Sa position affichée chez les
* autres clients peut alors suivre la contraption autrement que ses positions serveur : on ne mesure pas.
*/
public static boolean cibleProcheContraption(Entity cible, int tick) {
if (cible instanceof ServerPlayer j) return pocheContraptionEnCache(j, marques(j.getUUID()), tick);
if (SableAcces.surSousNiveau(cible)) return true;
int dist = GardeSpec.distanceContraption();
if (dist <= 0) return false;
return !cible.level().getEntities(cible, cible.getBoundingBox().inflate(dist), Garde::estContraption).isEmpty();
}
/** Recul réel (F06). Auto-infligé (charge de vent à ses pieds) : grâce limitée, voir GraceRecul. */
@@ -476,6 +590,9 @@ public final class Garde {
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z});
Sanction sh = traiter(p, vh); // coup déjà porté : les suivants sont annulés (Moteur.coupsBloques)
if (sh == Sanction.EXPULSION) appliquerSanctionMouvement(p, sh, vh);
// #92 : œil des deux derniers paquets, pour le prochain coup.
m.oeilAvant = m.oeilDernier;
m.oeilDernier = new double[] {oeil.x, oeil.y, oeil.z};
}
m.mouvementTick = tick;
m.mouvementX = p.getX();
+6 -1
Voir le fichier
@@ -44,6 +44,7 @@ public final class GardeEvents {
@SubscribeEvent
public static void onTickPre(ServerTickEvent.Pre event) {
debutTickNs = System.nanoTime();
Garde.enregistrerHistoriques(event.getServer()); // #92 : boîtes des cibles possibles
}
@SubscribeEvent
@@ -82,10 +83,14 @@ public final class GardeEvents {
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine)));
double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2)
+ Math.pow(cible.getZ() - cible.zo, 2));
// #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge
// « vitesse × ticks » dans toutes les directions. Null (pas de mesure) si l'historique est incomplet ou si
// la cible est sur ou près d'une contraption / d'un vaisseau.
double[][] vues = mesurerPH && !Garde.cibleProcheContraption(cible, tick) ? Garde.boitesVues(cible, p, tick) : null;
verdicts.addAll(Garde.moteur().coupDiffere(p.getUUID(), tick * 50L, etat,
new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z},
new double[] {bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ}, p.entityInteractionRange(),
vitesseCible, mesurerPH, true));
vitesseCible, mesurerPH, true, Garde.oeilAvant(p), vues));
if (Garde.tracesEnCours()) {
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(),
+35
Voir le fichier
@@ -47,6 +47,15 @@ public final class GardeSpec {
private static final ModConfigSpec.IntValue PING_LATENCE_MAX;
private static final ModConfigSpec.DoubleValue VITESSE_CIBLE_MAX;
private static final ModConfigSpec.IntValue TICKS_AFFICHAGE;
private static final ModConfigSpec.IntValue SERIE_PING_MAX;
private static final ModConfigSpec.DoubleValue SERIE_MANQUE;
private static final ModConfigSpec.DoubleValue SERIE_PORTEE;
private static final ModConfigSpec.IntValue SERIE_COUPS;
private static final ModConfigSpec.IntValue SERIE_HORS_MIN;
private static final ModConfigSpec.IntValue SERIE_FENETRE_MS;
private static final ModConfigSpec.DoubleValue SERIE_POINTS;
private static final ModConfigSpec.ConfigValue<String> PREFIXES_CONTRAPTION;
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
private static final ModConfigSpec.ConfigValue<String> BLOCS_COURANT_AIR;
@@ -110,6 +119,24 @@ public final class GardeSpec {
.defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
b.pop();
b.comment("Contrôle coups-hors-boite (#92) : le regard est testé contre toutes les positions où le client a pu",
"voir la cible (historique des boîtes), au lieu d'une marge « vitesse × ticks » dans toutes les directions.",
"Un coup isolé ne compte pas : seulement une série (serieHorsMin coups hors boîte sur les serieCoups derniers).",
"Valeurs de départ prudentes, à régler avec les journaux en OBSERVE avant tout ENFORCE.").push("coupsHorsBoite");
TICKS_AFFICHAGE = b.comment("Retard d'affichage de base de la cible chez le client (ticks) ; le ping s'ajoute (ping / 50).")
.defineInRange("ticksAffichageCible", 7, 2, 12);
SERIE_PING_MAX = b.comment("Ping (ms) au-delà duquel le coup n'est pas mesuré.")
.defineInRange("seriePingMaxMs", 500, 100, 500);
SERIE_MANQUE = b.comment("Coup hors boîte si le regard manque toutes les boîtes vues de plus de cette marge (blocs).")
.defineInRange("serieManqueBlocs", 0.15, 0.05, 2.0);
SERIE_PORTEE = b.comment("... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs).")
.defineInRange("seriePorteeMargeBlocs", 0.15, 0.05, 2.0);
SERIE_COUPS = b.defineInRange("serieCoups", 10, 3, 32);
SERIE_HORS_MIN = b.defineInRange("serieHorsMin", 4, 2, 32);
SERIE_FENETRE_MS = b.defineInRange("serieFenetreMs", 30000, 1000, 600000);
SERIE_POINTS = b.defineInRange("seriePoints", 2.0, 0.1, 20.0);
b.pop();
b.push("timer");
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
@@ -219,6 +246,14 @@ public final class GardeSpec {
c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get();
c.pingLatenceMaxMs = PING_LATENCE_MAX.get();
c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get();
c.ticksAffichageCible = TICKS_AFFICHAGE.get();
c.seriePingMaxMs = SERIE_PING_MAX.get();
c.serieManqueBlocs = SERIE_MANQUE.get();
c.seriePorteeMargeBlocs = SERIE_PORTEE.get();
c.serieCoups = SERIE_COUPS.get();
c.serieHorsMin = Math.min(SERIE_HORS_MIN.get(), c.serieCoups);
c.serieFenetreMs = SERIE_FENETRE_MS.get();
c.seriePoints = SERIE_POINTS.get();
c.graceTeleportTicks = GRACE_TELEPORT.get();
c.graceReculTicks = GRACE_RECUL.get();
c.graceGelTicks = GRACE_GEL.get();
+4 -1
Voir le fichier
@@ -10,6 +10,8 @@ public enum Controle {
ROTATION("rotation"),
PORTEE("portee"),
HITBOX("hitbox"),
/** #92 : série de coups qui manquent toutes les positions où la cible a pu être vue (hitbox, reach). */
COUPS_HORS_BOITE("coups-hors-boite"),
TIMER("timer"),
NO_FALL("no-fall"),
VITESSE("vitesse"),
@@ -33,7 +35,8 @@ public enum Controle {
* correction de l'interdiction du 15/10, qui empêchait aussi la correction no-fall de d0c001d).
*/
public boolean observeParDefaut() {
return this == NO_FALL || this == VITESSE || this == VOL || this == PORTEE || this == HITBOX;
return this == NO_FALL || this == VITESSE || this == VOL || this == PORTEE || this == HITBOX
|| this == COUPS_HORS_BOITE;
}
public static Controle parse(String texte) {
+9
Voir le fichier
@@ -27,6 +27,13 @@ final class CoupDiffere {
/** Excédent d'angle killaura (degrés), -1 si non mesuré. */
double excedent;
// #92 : mesure compensée par l'historique de la cible (contrôle coups-hors-boite). Null : pas d'historique.
double[][] boitesVues;
/** Œil au paquet d'avant, au coup, au paquet suivant (null si inconnu). */
double[] oeilPrecedent, oeilCoup, oeilSuivant;
/** Regard au coup et au paquet suivant (null si inconnu). */
double[] regardCoup, regardSuivant;
CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
double distance, double manque, double excedent, boolean porteeHitbox) {
this.nowMs = nowMs;
@@ -47,6 +54,8 @@ final class CoupDiffere {
/** Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. */
void affiner(double[] oeil, double[] regard) {
oeilSuivant = oeil.clone();
regardSuivant = regard.clone();
double[] b = boite;
double d = PorteeHitbox.distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]);
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
+21
Voir le fichier
@@ -58,6 +58,27 @@ public final class GardeConfig {
/** Cible plus rapide que ça (blocs/tick : élytres, riptide, téléportation, recul fort) : pas de mesure. */
public double vitesseCibleMaxMesure = 1.0;
// --- Coups hors boîte (#92, 16/10 : le cas de Rednixxu passait sous portee et hitbox) ---
/**
* Retard d'affichage de base de la cible chez le client (ticks) : envoi de sa position toutes les 2 (joueur) à
* 3 ticks (mob), interpolation sur 3 ticks, plus 1 tick de gigue. Le ping s'ajoute (voir seriePingMaxMs).
*/
public int ticksAffichageCible = 7;
/** Ping (ms) au-delà duquel la mesure compensée n'est pas faite (fenêtre plus large que l'historique fiable). */
public int seriePingMaxMs = 500;
/** Un coup est « hors boîte » si le regard manque toutes les boîtes vues de plus de cette marge (blocs). */
public double serieManqueBlocs = 0.15;
/** ... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs). */
public double seriePorteeMargeBlocs = 0.15;
/** Nombre de derniers coups mesurés examinés. */
public int serieCoups = 10;
/** Coups hors boîte, parmi les serieCoups derniers, à partir desquels un coup hors boîte compte. */
public int serieHorsMin = 4;
/** Âge maximal (ms) d'un coup encore compté dans la série. */
public long serieFenetreMs = 30000;
/** Points par coup hors boîte dans une série suspecte. */
public double seriePoints = 2.0;
// --- Exemptions ---
public int graceTeleportTicks = 40;
public int graceReculTicks = 20;
+94
Voir le fichier
@@ -0,0 +1,94 @@
package com.gastinelgarde.core;
/**
* Boîtes successives d'une entité, une par tick serveur (#92, 16/10/2026). Tampon circulaire de taille fixe (D4) :
* aucune allocation à l'enregistrement.
*
* Sert à savoir où un client a pu VOIR la cible au moment de son coup : le client affiche les autres entités avec
* du retard (envoi de position toutes les 2 ticks pour un joueur, 3 pour la plupart des mobs, interpolation sur
* 3 ticks, plus le ping). Au lieu d'élargir la boîte réelle dans toutes les directions de « vitesse × ticks »
* (ancien calcul, qui donnait jusqu'à 1 bloc de marge partout dès que la cible bouge), on teste le regard contre
* les boîtes réellement occupées pendant cette fenêtre.
*/
public final class HistoriqueBoites {
/** 32 ticks (1,6 s) : couvre la fenêtre la plus large (7 ticks + 500 ms de ping = 17 ticks) avec de la marge. */
public static final int CAPACITE = 32;
private final int[] ticks = new int[CAPACITE];
private final double[] boites = new double[CAPACITE * 6];
/** Nombre d'entrées valides. */
private int taille;
/** Indice de la prochaine écriture. */
private int tete;
/** Enregistre la boîte du tick ; un second enregistrement au même tick remplace le premier. */
public void ajouter(int tick, double minX, double minY, double minZ, double maxX, double maxY, double maxZ) {
int i;
if (taille > 0 && ticks[indice(taille - 1)] == tick) {
i = indice(taille - 1);
} else {
if (taille > 0 && tick < ticks[indice(taille - 1)]) vider(); // horloge revenue en arrière : on repart
i = tete;
tete = (tete + 1) % CAPACITE;
if (taille < CAPACITE) taille++;
}
ticks[i] = tick;
int o = i * 6;
boites[o] = minX;
boites[o + 1] = minY;
boites[o + 2] = minZ;
boites[o + 3] = maxX;
boites[o + 4] = maxY;
boites[o + 5] = maxZ;
}
public void ajouter(int tick, double[] b) {
ajouter(tick, b[0], b[1], b[2], b[3], b[4], b[5]);
}
public void vider() {
taille = 0;
tete = 0;
}
public int taille() {
return taille;
}
/** Tick de l'entrée la plus récente, ou {@link Integer#MIN_VALUE} si vide. */
public int dernierTick() {
return taille == 0 ? Integer.MIN_VALUE : ticks[indice(taille - 1)];
}
/** Tick de l'entrée la plus ancienne, ou {@link Integer#MAX_VALUE} si vide. */
public int premierTick() {
return taille == 0 ? Integer.MAX_VALUE : ticks[indice(0)];
}
/**
* Boîtes de la fenêtre [tickMin, ...], dans l'ordre chronologique, plus la dernière entrée antérieure à tickMin
* (la cible affichée peut être en cours d'interpolation depuis cette position).
*
* @return null si l'historique ne remonte pas jusqu'à tickMin (fenêtre incomplète : on ne sait pas où le client
* a pu voir la cible, donc on ne mesure pas)
*/
public double[][] depuis(int tickMin) {
if (taille == 0 || premierTick() > tickMin) return null;
int debut = 0;
for (int k = taille - 1; k >= 0; k--) {
if (ticks[indice(k)] <= tickMin) { debut = k; break; }
}
double[][] sortie = new double[taille - debut][];
for (int k = debut; k < taille; k++) {
int o = indice(k) * 6;
sortie[k - debut] = new double[] {boites[o], boites[o + 1], boites[o + 2], boites[o + 3], boites[o + 4], boites[o + 5]};
}
return sortie;
}
/** Indice dans le tampon de la k-ième entrée valide (0 = la plus ancienne). */
private int indice(int k) {
return ((tete - taille + k) % CAPACITE + CAPACITE) % CAPACITE;
}
}
+60 -2
Voir le fichier
@@ -149,11 +149,29 @@ public final class Moteur {
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
double[] boite, double porteeJoueur, double vitesseCible,
boolean porteeHitbox, boolean angle) {
return coupDiffere(joueur, nowMs, etat, oeil, regard, boite, porteeJoueur, vitesseCible, porteeHitbox, angle,
null, null);
}
/**
* Idem, avec ce qu'il faut pour la mesure compensée du contrôle coups-hors-boite (#92).
*
* @param oeilPrecedent œil au paquet de mouvement d'avant le dernier (null si inconnu)
* @param boitesVues boîtes de la cible sur la fenêtre où le client a pu la voir, dans l'ordre chronologique
* (voir {@link HistoriqueBoites#depuis} et {@link PorteeHitbox#ticksFenetre}) ; null si
* l'historique est incomplet : le contrôle ne mesure pas ce coup
*/
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
double[] boite, double porteeJoueur, double vitesseCible,
boolean porteeHitbox, boolean angle, double[] oeilPrecedent,
double[][] boitesVues) {
List<Verdict> verdicts = terminerCoup(joueur);
boolean serie = porteeHitbox && boitesVues != null && boitesVues.length > 0
&& cfg.mode(Controle.COUPS_HORS_BOITE) != Mode.OFF;
boolean ph = porteeHitbox
&& (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF);
boolean an = angle && cfg.mode(Controle.KILLAURA_ANGLE) != Mode.OFF;
if (!ph && !an) return verdicts;
if (!ph && !an && !serie) return verdicts;
double ex = an ? KillauraAngle.excedentDegres(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]) : -1;
if (an && ex < 0) ex = -1;
@@ -161,7 +179,46 @@ public final class Moteur {
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
porteeJoueur + 1.0, boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]);
suivi(joueur).coupDiffere = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
CoupDiffere c = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph);
if (serie) {
c.boitesVues = boitesVues;
c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone();
c.oeilCoup = oeil.clone();
c.regardCoup = regard.clone();
}
suivi(joueur).coupDiffere = c;
return verdicts;
}
/**
* Contrôle coups-hors-boite (#92) : mesure compensée du coup (toutes les positions où la cible a pu être vue,
* tous les yeux et regards plausibles de l'attaquant), puis série sur les derniers coups.
*/
private List<Verdict> coupsHorsBoite(Suivi s, CoupDiffere c) {
if (c.boitesVues == null || cfg.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return List.of();
Exemptions.Resultat ex = Exemptions.evaluer(c.etat, cfg, Exemptions.Famille.COMBAT);
if (ex.exempt()) return List.of();
if (PorteeHitbox.raisonNonMesureSerie(c.etat, cfg) != null) return List.of();
double[][] boites = new double[c.boitesVues.length + 1][];
System.arraycopy(c.boitesVues, 0, boites, 0, c.boitesVues.length);
boites[c.boitesVues.length] = c.boite; // boîte au moment du coup
PorteeHitbox.Mesure m = PorteeHitbox.mesureCompensee(
new double[][] {c.oeilPrecedent, c.oeilCoup, c.oeilSuivant},
new double[][] {c.regardCoup, c.regardSuivant},
boites, c.porteeJoueur + 1.0, cfg.vitesseCibleMaxMesure);
// Cible qui a sauté (téléportation) ou file trop vite dans la fenêtre : on ne sait pas ce que le client a vu.
if (m.deplacementMax() > cfg.vitesseCibleMaxMesure) return List.of();
double f = ex.facteur();
double seuilManque = cfg.serieManqueBlocs * f;
double seuilPortee = c.porteeJoueur + cfg.seriePorteeMargeBlocs * f;
boolean hors = m.manque() > seuilManque || m.distance() > seuilPortee;
double pts = s.serie.enregistrer(c.nowMs, hors, cfg);
List<Verdict> verdicts = new ArrayList<>(1);
ajouter(verdicts, s, Controle.COUPS_HORS_BOITE, pts, c.nowMs, ex, String.format(Locale.ROOT,
"manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d",
m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal()));
return verdicts;
}
@@ -192,6 +249,7 @@ public final class Moteur {
if (c.porteeHitbox) {
verdicts.addAll(porteeHitbox(joueur, c.nowMs, c.etat, c.distance, c.manque, c.porteeJoueur, c.vitesseCible));
}
verdicts.addAll(coupsHorsBoite(s, c));
for (Verdict v : verdicts) { // le coup est déjà passé : en ENFORCE, on annule les suivants
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
s.coupsBloquesJusqua = Math.max(s.coupsBloquesJusqua, c.nowMs + DUREE_BLOCAGE_COUPS_MS);
+89
Voir le fichier
@@ -126,4 +126,93 @@ public final class PorteeHitbox {
if (!(manque > seuil)) return 0;
return 1.0 + Math.min(2.0, (manque - seuil) / 0.3);
}
// --- Mesure compensée par l'historique de la cible (#92, contrôle coups-hors-boite) ----------------------
/**
* Écart maximal (en entrées d'historique) entre deux boîtes réunies : la cible affichée est interpolée en
* ligne droite entre deux positions reçues, espacées de 2 ticks (joueur) à 3 ticks (mob) ; la boîte englobante
* de deux boîtes contient tout le segment qui les relie.
*/
public static final int ECART_REUNION_MAX = 3;
/**
* Mesure compensée.
*
* @param distance distance minimale œil – boîte, sur tous les yeux et toutes les boîtes candidates
* @param manque gonflement minimal pour que l'un des regards touche l'une des boîtes candidates
* @param deplacementMax plus grand déplacement de la cible d'une entrée d'historique à la suivante (blocs)
*/
public record Mesure(double distance, double manque, double deplacementMax) { }
/**
* Fenêtre d'historique (ticks) où le client a pu voir la cible : retard d'affichage de base, plus le ping
* (aller-retour : la position part vers l'attaquant, le coup revient), borné.
*/
public static int ticksFenetre(int pingMs, GardeConfig cfg) {
int ping = Math.min(Math.max(0, pingMs), Math.max(0, cfg.seriePingMaxMs));
return Math.max(0, cfg.ticksAffichageCible) + (int) Math.ceil(ping / 50.0);
}
/**
* Distance et manque minimaux sur toutes les combinaisons (œil, regard, boîte candidate). Boîtes candidates :
* chaque boîte de l'historique, et la boîte englobante de deux boîtes distantes d'au plus
* {@link #ECART_REUNION_MAX} entrées (position interpolée entre les deux), sauf si la cible a « sauté » plus
* de {@code sautMax} blocs par entrée entre elles (téléportation : pas d'interpolation).
*
* Toutes les sources d'écart honnêtes sont prises du côté favorable au joueur : œil précédent, actuel et
* suivant (le client vise depuis une position interpolée entre deux paquets), regard actuel et suivant.
*/
public static Mesure mesureCompensee(double[][] yeux, double[][] regards, double[][] boites, double longueur,
double sautMax) {
double distance = Double.MAX_VALUE;
double manque = MANQUE_MAX;
double deplacementMax = 0;
for (int i = 1; i < boites.length; i++) deplacementMax = Math.max(deplacementMax, ecartCentres(boites[i - 1], boites[i]));
for (int i = 0; i < boites.length; i++) {
for (int k = 0; k <= ECART_REUNION_MAX && i + k < boites.length; k++) {
double[] b;
if (k == 0) {
b = boites[i];
} else {
if (ecartCentres(boites[i], boites[i + k]) > sautMax * k) continue;
b = reunion(boites[i], boites[i + k]);
}
for (double[] oeil : yeux) {
if (oeil == null) continue;
distance = Math.min(distance, distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]));
for (double[] r : regards) {
if (r == null || manque == 0) continue;
manque = Math.min(manque, manqueRegard(oeil[0], oeil[1], oeil[2], r[0], r[1], r[2], longueur,
b[0], b[1], b[2], b[3], b[4], b[5]));
}
}
}
}
if (distance == Double.MAX_VALUE) distance = 0;
return new Mesure(distance, manque, deplacementMax);
}
static double ecartCentres(double[] a, double[] b) {
double dx = (a[0] + a[3] - b[0] - b[3]) / 2, dy = (a[1] + a[4] - b[1] - b[4]) / 2, dz = (a[2] + a[5] - b[2] - b[5]) / 2;
return Math.sqrt(dx * dx + dy * dy + dz * dz);
}
static double[] reunion(double[] a, double[] b) {
return new double[] {Math.min(a[0], b[0]), Math.min(a[1], b[1]), Math.min(a[2], b[2]),
Math.max(a[3], b[3]), Math.max(a[4], b[4]), Math.max(a[5], b[5])};
}
/**
* Situations où la mesure compensée n'est pas fiable (en plus de {@link #raisonNonMesure}, sans la vitesse
* instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées), ping au-delà
* de {@link GardeConfig#seriePingMaxMs} (la fenêtre ne couvrirait plus le retard d'affichage).
*/
public static String raisonNonMesureSerie(EtatJoueur e, GardeConfig cfg) {
String r = raisonNonMesure(e, 0, cfg);
if (r != null) return r;
if (e.ticksDepuisGel() <= cfg.graceGelTicks) return "gel-serveur";
if (e.pingMs() > cfg.seriePingMaxMs) return "ping";
return null;
}
}
+62
Voir le fichier
@@ -0,0 +1,62 @@
package com.gastinelgarde.core;
/**
* Contrôle « coups-hors-boite » (#92, 16/10/2026) : sur les derniers coups mesurés, combien ont touché une cible
* que le regard ne touchait nulle part, même en tenant compte de toutes les positions où le client a pu la voir.
*
* Un joueur honnête vise ce qu'il voit : sa mesure compensée vaut 0 (aux erreurs de modèle près, rares et isolées).
* Un client « hitbox » (boîtes grossies) ou « reach » touche régulièrement à côté ou trop loin. Un coup isolé ne
* prouve rien ; une proportion soutenue, si. Tampon de taille fixe, aucune allocation.
*/
public final class SerieCoups {
public static final int TAILLE_MAX = 32;
private final long[] instants = new long[TAILLE_MAX];
private final boolean[] hors = new boolean[TAILLE_MAX];
private int taille;
private int tete;
private int dernierCompte;
private int dernierTotal;
/**
* Enregistre un coup mesuré.
*
* @return points : {@link GardeConfig#seriePoints} si ce coup est hors boîte ET qu'au moins
* {@link GardeConfig#serieHorsMin} des {@link GardeConfig#serieCoups} derniers coups (dans
* {@link GardeConfig#serieFenetreMs}) le sont aussi ; 0 sinon.
*/
public double enregistrer(long nowMs, boolean horsBoite, GardeConfig cfg) {
int n = Math.max(1, Math.min(TAILLE_MAX, cfg.serieCoups));
instants[tete] = nowMs;
hors[tete] = horsBoite;
tete = (tete + 1) % TAILLE_MAX;
if (taille < TAILLE_MAX) taille++;
int compte = 0, total = 0;
for (int k = 0; k < Math.min(n, taille); k++) {
int i = ((tete - 1 - k) % TAILLE_MAX + TAILLE_MAX) % TAILLE_MAX;
if (nowMs - instants[i] > cfg.serieFenetreMs || instants[i] > nowMs) break;
total++;
if (hors[i]) compte++;
}
dernierCompte = compte;
dernierTotal = total;
return horsBoite && compte >= cfg.serieHorsMin ? cfg.seriePoints : 0;
}
/** Coups hors boîte parmi les derniers comptés (pour le journal). */
public int dernierCompte() {
return dernierCompte;
}
/** Coups comptés au dernier enregistrement (pour le journal). */
public int dernierTotal() {
return dernierTotal;
}
public void vider() {
taille = 0;
tete = 0;
}
}
+2
Voir le fichier
@@ -14,6 +14,8 @@ public final class Suivi {
public final VitesseHorizontale vitesse = new VitesseHorizontale();
public final VolVertical vol = new VolVertical();
public final VehiculeMouvement vehicule = new VehiculeMouvement();
/** #92 : derniers coups mesurés avec l'historique de la cible (contrôle coups-hors-boite). */
public final SerieCoups serie = new SerieCoups();
/** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */
CoupDiffere coupDiffere;
+64
Voir le fichier
@@ -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();
}
}
}
+363
Voir le fichier
@@ -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);
}
}
+259
Voir le fichier
@@ -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");
}
}
+272
Voir le fichier
@@ -0,0 +1,272 @@
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.
*
* 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).
*
* 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);
if (vs.isEmpty()) { // Garde.apresMouvement : m.dernierVerdictTick != tick
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;
}
// --- C1 : pas de grâce de sortie d'élytres pour le vol ----------------------------------------------------------
@Test
void FAUX_POSITIF_C1_planeDElytresDontLeDrapeauTombeEstPrisPourDuVol() {
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;
}
// 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);
}
@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 mémorisé en l'air -----------------------------------------------------------------------
@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));
}
@Test
void FAILLE_C3_unVolDeDixTicksGardeLAltitudeGagneeDansLePointDeRetour() {
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));
}
// --- C2, C5, C4 : setback sans remise à zéro, escalade en moins d'une seconde, expulsion répétée ------------------
@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++;
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() {
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
double v = 0.42;
for (int i = 0; i < 5; i++) {
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));
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);
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;
} else if (s == Sanction.EXPULSION) {
expulsionTick = tick;
}
}
assertTrue(expulsionTick > 0, "expulsion atteinte");
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);
// 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");
}
@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)");
}
}
+261
Voir le fichier
@@ -0,0 +1,261 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
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;
/**
* #92 (16/10/2026) : test hitbox / portée de Rednixxu non détecté.
*
* Cause reproduite ici : dès que la cible bouge (marche, sprint), l'ancien calcul ajoutait « vitesse × (3 + ping/50)
* ticks », plafonné à 1,0 bloc, aux deux seuils, dans toutes les directions. Une cible qui sprinte (0,28 bloc/tick)
* donnait donc une hitbox tolérée de 0,25 + 1,0 = 1,25 bloc et une portée de 3,0 + 0,3 + 1,0 = 4,3 blocs, au-delà
* même du refus vanilla (4,0) : portée et hitbox ne pouvaient plus rien voir.
*
* Correctif : contrôle coups-hors-boite, mesure contre les boîtes réellement occupées par la cible pendant la
* fenêtre où le client a pu la voir, et sanction seulement sur une série.
*/
class Garde92Test {
private static final double V = 0.28; // sprint, 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. */
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 points(List<Verdict> vs, Controle c) {
double p = 0;
for (Verdict v : vs) if (v.controle() == c) p += v.points();
return p;
}
/** Un coup complet (coup + paquet de mouvement suivant) ; renvoie tous les verdicts. */
private List<Verdict> coup(long t, EtatJoueur etat, double[] oeil, double[] regard, double xCible, double vitesse,
double[][] vues) {
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, t, etat, oeil, regard, boite(xCible), 3.0,
vitesse, true, false, oeil, vues));
vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeil, regard));
return vs;
}
private static double[] vers(double[] de, double x, double y, double z) {
return new double[] {x - de[0], y - de[1], z - de[2]};
}
// --- Le cas de Rednixxu -----------------------------------------------------------------------------------
@Test
void hitboxGrossieSurCibleQuiSprinteEtaitInvisiblePourLAncienControleEtEstVueEnSerie() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double ancien = 0, nouveau = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
// Le client « hitbox » touche 0,45 bloc devant le bord avant de la cible : là où elle n'a jamais été.
double[] regard = vers(oeil, x + 0.75, 1.2, 0);
List<Verdict> vs = coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre));
ancien += points(vs, Controle.HITBOX) + points(vs, Controle.PORTEE);
nouveau += points(vs, Controle.COUPS_HORS_BOITE);
}
assertEquals(0, ancien, 1e-9, "l'ancien contrôle ne voit rien (c'est le bogue reproduit)");
// 4e coup hors boîte : la série commence à compter, puis chaque coup suivant.
assertEquals(7 * cfg.seriePoints, nouveau, 1e-9);
}
@Test
void porteeAllongeeSurCibleQuiSprinteEstVueEnSerie() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double ancien = 0, nouveau = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.9}; // 3,6 blocs de la boîte : vanilla laisse passer (< 4,0)
double[] regard = vers(oeil, x, 1.2, 0);
List<Verdict> vs = coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre));
ancien += points(vs, Controle.HITBOX) + points(vs, Controle.PORTEE);
nouveau += points(vs, Controle.COUPS_HORS_BOITE);
}
assertEquals(0, ancien, 1e-9);
assertTrue(nouveau > 0);
}
@Test
void leNouveauControleEstEnObserveParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.COUPS_HORS_BOITE));
}
// --- Pas de faux positifs ---------------------------------------------------------------------------------
@Test
void joueurHonneteQuiViseLaCibleAfficheeEnRetardAvecPingNestJamaisCompte() {
int ping = 150;
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg);
for (int k = 0; k < 30; k++) {
double x = 5 * k;
int retard = k % (fenetre + 1); // la cible affichée a 0 à « fenetre » ticks de retard
double xVu = x - V * retard;
double[] oeil = {xVu, 1.62, -2.9};
// Visée sur le bord arrière de la boîte affichée, à 0,1 bloc près (imprécision du modèle).
double[] regard = vers(oeil, xVu - 0.3 - 0.1, 1.0, -0.3);
assertEquals(0, points(coup(k * 600L, etat, oeil, regard, x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE), 1e-9, "coup " + k);
}
}
@Test
void positionInterpoleeEntreDeuxPaquetsEstAcceptee() {
// Cible qui n'envoie sa position que toutes les 3 entrées : le client l'affiche entre deux.
double[][] b = {boite(0), boite(0), boite(0), boite(0.84), boite(0.84), boite(0.84)};
double[] oeil = {0.42, 1.62, -2.5};
double[] regard = vers(oeil, 0.42, 1.0, 0);
PorteeHitbox.Mesure m = PorteeHitbox.mesureCompensee(new double[][] {oeil}, new double[][] {regard}, b, 4.0, 1.0);
assertEquals(0, m.manque(), 1e-9);
}
@Test
void unCoupHorsBoiteIsoleNeCompteJamais() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double total = 0;
for (int k = 0; k < 40; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
double[] regard = k % 4 == 0 ? vers(oeil, x + 0.75, 1.2, 0) : vers(oeil, x, 1.2, 0); // 1 sur 4
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
@Test
void rotationEnRetardDUnTickRattrapeeParLeRegardSuivant() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
double[] ancienRegard = vers(oeil, x + 1.5, 1.2, 0); // regard du paquet d'avant
double[] regard = vers(oeil, x, 1.2, 0); // vrai regard, arrivé au paquet suivant
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, k * 600L, EtatJoueur.normal(), oeil,
ancienRegard, boite(x), 3.0, V, true, false, oeil, vues(x, fenetre)));
vs.addAll(moteur.regardPorteeHitbox(joueur, k * 600L + 50, oeil, regard));
total += points(vs, Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
@Test
void exemptionsCreatifMontureElytresPingTeleportationEtGel() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
List<EtatJoueur> etats = List.of(
EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().elytres(true).build(),
EtatJoueur.builder().riptide(true).build(),
EtatJoueur.builder().pingMs(cfg.seriePingMaxMs + 1).build(),
EtatJoueur.builder().ticksDepuisTeleport(5).build(),
EtatJoueur.builder().ticksDepuisGel(5).build());
for (EtatJoueur etat : etats) {
moteur = new Moteur(cfg);
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
total += points(coup(k * 600L, etat, oeil, vers(oeil, x + 0.75, 1.2, 0), x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9, etat.toString());
}
}
@Test
void cibleTeleporteeOuTropRapideOuContraptionNonMesuree() {
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);
double[][] saut = {boite(x - 10), boite(x - 10), boite(x), boite(x)}; // /tp de la cible
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, 0, saut), Controle.COUPS_HORS_BOITE);
// null : historique incomplet, ou cible sur / près d'une contraption Create ou d'un vaisseau Sable.
total += points(coup(k * 600L + 300, EtatJoueur.normal(), oeil, regard, x, 0, null),
Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
@Test
void controleOffNeMesureRien() {
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, vers(oeil, x + 0.75, 1.2, 0), x, V,
vues(x, fenetre)), Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
// --- Briques ----------------------------------------------------------------------------------------------
@Test
void historiqueBoitesFenetreIncompleteTamponCirculaireEtEntreeAnterieure() {
HistoriqueBoites h = new HistoriqueBoites();
assertNull(h.depuis(0));
for (int t = 10; t < 10 + HistoriqueBoites.CAPACITE + 5; t++) h.ajouter(t, boite(t));
assertEquals(HistoriqueBoites.CAPACITE, h.taille());
assertEquals(15, h.premierTick());
assertNull(h.depuis(14)); // plus ancien que l'historique : pas de mesure
double[][] d = h.depuis(40);
assertNotNull(d);
assertEquals(10 + HistoriqueBoites.CAPACITE + 5 - 40, d.length);
assertArrayEquals(boite(40), d[0], 1e-12);
h.ajouter(46, boite(0)); // même tick : remplacé
assertEquals(HistoriqueBoites.CAPACITE, h.taille());
h.ajouter(3, boite(0)); // horloge revenue en arrière : on repart
assertEquals(1, h.taille());
}
@Test
void fenetreBorneeParLePingMax() {
assertEquals(cfg.ticksAffichageCible, PorteeHitbox.ticksFenetre(0, cfg));
assertEquals(cfg.ticksAffichageCible + 3, PorteeHitbox.ticksFenetre(150, cfg));
int max = PorteeHitbox.ticksFenetre(cfg.seriePingMaxMs, cfg);
assertEquals(max, PorteeHitbox.ticksFenetre(100000, cfg));
assertTrue(max + 1 < HistoriqueBoites.CAPACITE);
}
@Test
void serieCoupsOublieLesCoupsTropAnciens() {
SerieCoups s = new SerieCoups();
for (int k = 0; k < 3; k++) s.enregistrer(k * 1000L, true, cfg);
// 4e coup hors boîte, mais les 3 premiers sont hors de la fenêtre de 30 s.
assertEquals(0, s.enregistrer(3 * 1000L + cfg.serieFenetreMs + 1, true, cfg), 1e-9);
assertEquals(1, s.dernierTotal());
}
}
+27
Voir le fichier
@@ -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
}
}
}