Comparer les révisions
5
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
44504eca0c | |||
|
|
bbb08a95f8 | |||
|
|
bfc8f5719c | |||
|
|
937d43d499 | |||
|
|
7a5a1c92c8 | |||
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
|
||||||
@@ -8,6 +8,8 @@ import com.gastinelgarde.core.EtatVehicule;
|
|||||||
import com.gastinelgarde.core.GardeConfig;
|
import com.gastinelgarde.core.GardeConfig;
|
||||||
import com.gastinelgarde.core.GraceRecul;
|
import com.gastinelgarde.core.GraceRecul;
|
||||||
import com.gastinelgarde.core.GraceTeleport;
|
import com.gastinelgarde.core.GraceTeleport;
|
||||||
|
import com.gastinelgarde.core.HistoriqueBoites;
|
||||||
|
import com.gastinelgarde.core.PorteeHitbox;
|
||||||
import com.gastinelgarde.core.Mode;
|
import com.gastinelgarde.core.Mode;
|
||||||
import com.gastinelgarde.core.Moteur;
|
import com.gastinelgarde.core.Moteur;
|
||||||
import com.gastinelgarde.core.RiptideSuivi;
|
import com.gastinelgarde.core.RiptideSuivi;
|
||||||
@@ -82,8 +84,31 @@ public final class Garde {
|
|||||||
int courantTick = Integer.MIN_VALUE;
|
int courantTick = Integer.MIN_VALUE;
|
||||||
int courantVuTick = Integer.MIN_VALUE;
|
int courantVuTick = Integer.MIN_VALUE;
|
||||||
boolean courantProche;
|
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 GardeConfig CONFIG = new GardeConfig();
|
||||||
private static final Moteur MOTEUR = new Moteur(CONFIG);
|
private static final Moteur MOTEUR = new Moteur(CONFIG);
|
||||||
private static final Map<UUID, Marques> MARQUES = new HashMap<>();
|
private static final Map<UUID, Marques> MARQUES = new HashMap<>();
|
||||||
@@ -136,6 +161,7 @@ public final class Garde {
|
|||||||
traces = null;
|
traces = null;
|
||||||
}
|
}
|
||||||
MARQUES.clear();
|
MARQUES.clear();
|
||||||
|
SUIVIES.clear();
|
||||||
}
|
}
|
||||||
|
|
||||||
public static synchronized void flushTraces() {
|
public static synchronized void flushTraces() {
|
||||||
@@ -170,6 +196,8 @@ public final class Garde {
|
|||||||
m.teleportTick = p.server.getTickCount();
|
m.teleportTick = p.server.getTickCount();
|
||||||
m.mouvementTick = Integer.MIN_VALUE;
|
m.mouvementTick = Integer.MIN_VALUE;
|
||||||
m.vehiculeId = -1;
|
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). */
|
/** 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();
|
if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount();
|
||||||
m.mouvementTick = Integer.MIN_VALUE;
|
m.mouvementTick = Integer.MIN_VALUE;
|
||||||
m.vehiculeId = -1;
|
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. */
|
/** 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});
|
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)
|
Sanction sh = traiter(p, vh); // coup déjà porté : les suivants sont annulés (Moteur.coupsBloques)
|
||||||
if (sh == Sanction.EXPULSION) appliquerSanctionMouvement(p, sh, vh);
|
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.mouvementTick = tick;
|
||||||
m.mouvementX = p.getX();
|
m.mouvementX = p.getX();
|
||||||
|
|||||||
@@ -44,6 +44,7 @@ public final class GardeEvents {
|
|||||||
@SubscribeEvent
|
@SubscribeEvent
|
||||||
public static void onTickPre(ServerTickEvent.Pre event) {
|
public static void onTickPre(ServerTickEvent.Pre event) {
|
||||||
debutTickNs = System.nanoTime();
|
debutTickNs = System.nanoTime();
|
||||||
|
Garde.enregistrerHistoriques(event.getServer()); // #92 : boîtes des cibles possibles
|
||||||
}
|
}
|
||||||
|
|
||||||
@SubscribeEvent
|
@SubscribeEvent
|
||||||
@@ -82,10 +83,14 @@ public final class GardeEvents {
|
|||||||
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine)));
|
&& (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)
|
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));
|
+ 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,
|
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[] {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(),
|
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()) {
|
if (Garde.tracesEnCours()) {
|
||||||
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(),
|
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(),
|
||||||
|
|||||||
@@ -47,6 +47,15 @@ public final class GardeSpec {
|
|||||||
private static final ModConfigSpec.IntValue PING_LATENCE_MAX;
|
private static final ModConfigSpec.IntValue PING_LATENCE_MAX;
|
||||||
private static final ModConfigSpec.DoubleValue VITESSE_CIBLE_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.ConfigValue<String> PREFIXES_CONTRAPTION;
|
||||||
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
|
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
|
||||||
private static final ModConfigSpec.ConfigValue<String> BLOCS_COURANT_AIR;
|
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);
|
.defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
|
||||||
b.pop();
|
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");
|
b.push("timer");
|
||||||
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
|
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
|
||||||
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
|
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
|
||||||
@@ -219,6 +246,14 @@ public final class GardeSpec {
|
|||||||
c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get();
|
c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get();
|
||||||
c.pingLatenceMaxMs = PING_LATENCE_MAX.get();
|
c.pingLatenceMaxMs = PING_LATENCE_MAX.get();
|
||||||
c.vitesseCibleMaxMesure = VITESSE_CIBLE_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.graceTeleportTicks = GRACE_TELEPORT.get();
|
||||||
c.graceReculTicks = GRACE_RECUL.get();
|
c.graceReculTicks = GRACE_RECUL.get();
|
||||||
c.graceGelTicks = GRACE_GEL.get();
|
c.graceGelTicks = GRACE_GEL.get();
|
||||||
|
|||||||
@@ -10,6 +10,8 @@ public enum Controle {
|
|||||||
ROTATION("rotation"),
|
ROTATION("rotation"),
|
||||||
PORTEE("portee"),
|
PORTEE("portee"),
|
||||||
HITBOX("hitbox"),
|
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"),
|
TIMER("timer"),
|
||||||
NO_FALL("no-fall"),
|
NO_FALL("no-fall"),
|
||||||
VITESSE("vitesse"),
|
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).
|
* correction de l'interdiction du 15/10, qui empêchait aussi la correction no-fall de d0c001d).
|
||||||
*/
|
*/
|
||||||
public boolean observeParDefaut() {
|
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) {
|
public static Controle parse(String texte) {
|
||||||
|
|||||||
@@ -27,6 +27,13 @@ final class CoupDiffere {
|
|||||||
/** Excédent d'angle killaura (degrés), -1 si non mesuré. */
|
/** Excédent d'angle killaura (degrés), -1 si non mesuré. */
|
||||||
double excedent;
|
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,
|
CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
|
||||||
double distance, double manque, double excedent, boolean porteeHitbox) {
|
double distance, double manque, double excedent, boolean porteeHitbox) {
|
||||||
this.nowMs = nowMs;
|
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. */
|
/** Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. */
|
||||||
void affiner(double[] oeil, double[] regard) {
|
void affiner(double[] oeil, double[] regard) {
|
||||||
|
oeilSuivant = oeil.clone();
|
||||||
|
regardSuivant = regard.clone();
|
||||||
double[] b = boite;
|
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 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],
|
double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2],
|
||||||
|
|||||||
@@ -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. */
|
/** Cible plus rapide que ça (blocs/tick : élytres, riptide, téléportation, recul fort) : pas de mesure. */
|
||||||
public double vitesseCibleMaxMesure = 1.0;
|
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 ---
|
// --- Exemptions ---
|
||||||
public int graceTeleportTicks = 40;
|
public int graceTeleportTicks = 40;
|
||||||
public int graceReculTicks = 20;
|
public int graceReculTicks = 20;
|
||||||
|
|||||||
@@ -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;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -149,11 +149,29 @@ public final class Moteur {
|
|||||||
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
|
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
|
||||||
double[] boite, double porteeJoueur, double vitesseCible,
|
double[] boite, double porteeJoueur, double vitesseCible,
|
||||||
boolean porteeHitbox, boolean angle) {
|
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);
|
List<Verdict> verdicts = terminerCoup(joueur);
|
||||||
|
boolean serie = porteeHitbox && boitesVues != null && boitesVues.length > 0
|
||||||
|
&& cfg.mode(Controle.COUPS_HORS_BOITE) != Mode.OFF;
|
||||||
boolean ph = porteeHitbox
|
boolean ph = porteeHitbox
|
||||||
&& (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF);
|
&& (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF);
|
||||||
boolean an = angle && cfg.mode(Controle.KILLAURA_ANGLE) != 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],
|
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;
|
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]) : -1;
|
||||||
if (an && ex < 0) ex = -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]);
|
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],
|
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]);
|
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;
|
return verdicts;
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -192,6 +249,7 @@ public final class Moteur {
|
|||||||
if (c.porteeHitbox) {
|
if (c.porteeHitbox) {
|
||||||
verdicts.addAll(porteeHitbox(joueur, c.nowMs, c.etat, c.distance, c.manque, c.porteeJoueur, c.vitesseCible));
|
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
|
for (Verdict v : verdicts) { // le coup est déjà passé : en ENFORCE, on annule les suivants
|
||||||
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
|
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
|
||||||
s.coupsBloquesJusqua = Math.max(s.coupsBloquesJusqua, c.nowMs + DUREE_BLOCAGE_COUPS_MS);
|
s.coupsBloquesJusqua = Math.max(s.coupsBloquesJusqua, c.nowMs + DUREE_BLOCAGE_COUPS_MS);
|
||||||
|
|||||||
@@ -126,4 +126,93 @@ public final class PorteeHitbox {
|
|||||||
if (!(manque > seuil)) return 0;
|
if (!(manque > seuil)) return 0;
|
||||||
return 1.0 + Math.min(2.0, (manque - seuil) / 0.3);
|
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;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
@@ -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;
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -14,6 +14,8 @@ public final class Suivi {
|
|||||||
public final VitesseHorizontale vitesse = new VitesseHorizontale();
|
public final VitesseHorizontale vitesse = new VitesseHorizontale();
|
||||||
public final VolVertical vol = new VolVertical();
|
public final VolVertical vol = new VolVertical();
|
||||||
public final VehiculeMouvement vehicule = new VehiculeMouvement();
|
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}). */
|
/** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */
|
||||||
CoupDiffere coupDiffere;
|
CoupDiffere coupDiffere;
|
||||||
|
|||||||
@@ -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,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)");
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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());
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -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