GastinelGarde #92 : tests du controle coups-hors-boite (cas Rednixxu, faux positifs)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Opus 5.5 a révisé 2026-10-16 00:55:32 +02:00
1 Parent 7a5a1c92c8
révision 937d43d499
1 fichier modifié
+261
+261
Voir le fichier
@@ -0,0 +1,261 @@
package com.gastinelgarde.core;
import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertNull;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
/**
* #92 (16/10/2026) : test hitbox / portée de Rednixxu non détecté.
*
* Cause reproduite ici : dès que la cible bouge (marche, sprint), l'ancien calcul ajoutait « vitesse × (3 + ping/50)
* ticks », plafonné à 1,0 bloc, aux deux seuils, dans toutes les directions. Une cible qui sprinte (0,28 bloc/tick)
* donnait donc une hitbox tolérée de 0,25 + 1,0 = 1,25 bloc et une portée de 3,0 + 0,3 + 1,0 = 4,3 blocs, au-delà
* même du refus vanilla (4,0) : portée et hitbox ne pouvaient plus rien voir.
*
* Correctif : contrôle coups-hors-boite, mesure contre les boîtes réellement occupées par la cible pendant la
* fenêtre où le client a pu la voir, et sanction seulement sur une série.
*/
class Garde92Test {
private static final double V = 0.28; // sprint, blocs/tick
private GardeConfig cfg;
private Moteur moteur;
private final UUID joueur = UUID.randomUUID();
@BeforeEach
void init() {
cfg = new GardeConfig();
moteur = new Moteur(cfg);
}
private static double[] boite(double x) {
return new double[] {x - 0.3, 0, -0.3, x + 0.3, 1.8, 0.3};
}
/** Boîtes vues : cible qui avance de V par tick en x, arrivée en xNow. */
private static double[][] vues(double xNow, int fenetre) {
double[][] b = new double[fenetre + 2][];
for (int i = 0; i < b.length; i++) b[i] = boite(xNow - V * (b.length - 1 - i));
return b;
}
private static double points(List<Verdict> vs, Controle c) {
double p = 0;
for (Verdict v : vs) if (v.controle() == c) p += v.points();
return p;
}
/** Un coup complet (coup + paquet de mouvement suivant) ; renvoie tous les verdicts. */
private List<Verdict> coup(long t, EtatJoueur etat, double[] oeil, double[] regard, double xCible, double vitesse,
double[][] vues) {
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, t, etat, oeil, regard, boite(xCible), 3.0,
vitesse, true, false, oeil, vues));
vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeil, regard));
return vs;
}
private static double[] vers(double[] de, double x, double y, double z) {
return new double[] {x - de[0], y - de[1], z - de[2]};
}
// --- Le cas de Rednixxu -----------------------------------------------------------------------------------
@Test
void hitboxGrossieSurCibleQuiSprinteEtaitInvisiblePourLAncienControleEtEstVueEnSerie() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double ancien = 0, nouveau = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
// Le client « hitbox » touche 0,45 bloc devant le bord avant de la cible : là où elle n'a jamais été.
double[] regard = vers(oeil, x + 0.75, 1.2, 0);
List<Verdict> vs = coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre));
ancien += points(vs, Controle.HITBOX) + points(vs, Controle.PORTEE);
nouveau += points(vs, Controle.COUPS_HORS_BOITE);
}
assertEquals(0, ancien, 1e-9, "l'ancien contrôle ne voit rien (c'est le bogue reproduit)");
// 4e coup hors boîte : la série commence à compter, puis chaque coup suivant.
assertEquals(7 * cfg.seriePoints, nouveau, 1e-9);
}
@Test
void porteeAllongeeSurCibleQuiSprinteEstVueEnSerie() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double ancien = 0, nouveau = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.9}; // 3,6 blocs de la boîte : vanilla laisse passer (< 4,0)
double[] regard = vers(oeil, x, 1.2, 0);
List<Verdict> vs = coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre));
ancien += points(vs, Controle.HITBOX) + points(vs, Controle.PORTEE);
nouveau += points(vs, Controle.COUPS_HORS_BOITE);
}
assertEquals(0, ancien, 1e-9);
assertTrue(nouveau > 0);
}
@Test
void leNouveauControleEstEnObserveParDefaut() {
assertEquals(Mode.OBSERVE, cfg.mode(Controle.COUPS_HORS_BOITE));
}
// --- Pas de faux positifs ---------------------------------------------------------------------------------
@Test
void joueurHonneteQuiViseLaCibleAfficheeEnRetardAvecPingNestJamaisCompte() {
int ping = 150;
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg);
for (int k = 0; k < 30; k++) {
double x = 5 * k;
int retard = k % (fenetre + 1); // la cible affichée a 0 à « fenetre » ticks de retard
double xVu = x - V * retard;
double[] oeil = {xVu, 1.62, -2.9};
// Visée sur le bord arrière de la boîte affichée, à 0,1 bloc près (imprécision du modèle).
double[] regard = vers(oeil, xVu - 0.3 - 0.1, 1.0, -0.3);
assertEquals(0, points(coup(k * 600L, etat, oeil, regard, x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE), 1e-9, "coup " + k);
}
}
@Test
void positionInterpoleeEntreDeuxPaquetsEstAcceptee() {
// Cible qui n'envoie sa position que toutes les 3 entrées : le client l'affiche entre deux.
double[][] b = {boite(0), boite(0), boite(0), boite(0.84), boite(0.84), boite(0.84)};
double[] oeil = {0.42, 1.62, -2.5};
double[] regard = vers(oeil, 0.42, 1.0, 0);
PorteeHitbox.Mesure m = PorteeHitbox.mesureCompensee(new double[][] {oeil}, new double[][] {regard}, b, 4.0, 1.0);
assertEquals(0, m.manque(), 1e-9);
}
@Test
void unCoupHorsBoiteIsoleNeCompteJamais() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double total = 0;
for (int k = 0; k < 40; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
double[] regard = k % 4 == 0 ? vers(oeil, x + 0.75, 1.2, 0) : vers(oeil, x, 1.2, 0); // 1 sur 4
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
@Test
void rotationEnRetardDUnTickRattrapeeParLeRegardSuivant() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
double[] ancienRegard = vers(oeil, x + 1.5, 1.2, 0); // regard du paquet d'avant
double[] regard = vers(oeil, x, 1.2, 0); // vrai regard, arrivé au paquet suivant
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, k * 600L, EtatJoueur.normal(), oeil,
ancienRegard, boite(x), 3.0, V, true, false, oeil, vues(x, fenetre)));
vs.addAll(moteur.regardPorteeHitbox(joueur, k * 600L + 50, oeil, regard));
total += points(vs, Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
@Test
void exemptionsCreatifMontureElytresPingTeleportationEtGel() {
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
List<EtatJoueur> etats = List.of(
EtatJoueur.builder().creatif(true).build(),
EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().elytres(true).build(),
EtatJoueur.builder().riptide(true).build(),
EtatJoueur.builder().pingMs(cfg.seriePingMaxMs + 1).build(),
EtatJoueur.builder().ticksDepuisTeleport(5).build(),
EtatJoueur.builder().ticksDepuisGel(5).build());
for (EtatJoueur etat : etats) {
moteur = new Moteur(cfg);
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
total += points(coup(k * 600L, etat, oeil, vers(oeil, x + 0.75, 1.2, 0), x, V, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9, etat.toString());
}
}
@Test
void cibleTeleporteeOuTropRapideOuContraptionNonMesuree() {
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
double[] regard = vers(oeil, x + 0.75, 1.2, 0);
double[][] saut = {boite(x - 10), boite(x - 10), boite(x), boite(x)}; // /tp de la cible
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, regard, x, 0, saut), Controle.COUPS_HORS_BOITE);
// null : historique incomplet, ou cible sur / près d'une contraption Create ou d'un vaisseau Sable.
total += points(coup(k * 600L + 300, EtatJoueur.normal(), oeil, regard, x, 0, null),
Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
@Test
void controleOffNeMesureRien() {
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
double total = 0;
for (int k = 0; k < 10; k++) {
double x = 5 * k;
double[] oeil = {x, 1.62, -3.0};
total += points(coup(k * 600L, EtatJoueur.normal(), oeil, vers(oeil, x + 0.75, 1.2, 0), x, V,
vues(x, fenetre)), Controle.COUPS_HORS_BOITE);
}
assertEquals(0, total, 1e-9);
}
// --- Briques ----------------------------------------------------------------------------------------------
@Test
void historiqueBoitesFenetreIncompleteTamponCirculaireEtEntreeAnterieure() {
HistoriqueBoites h = new HistoriqueBoites();
assertNull(h.depuis(0));
for (int t = 10; t < 10 + HistoriqueBoites.CAPACITE + 5; t++) h.ajouter(t, boite(t));
assertEquals(HistoriqueBoites.CAPACITE, h.taille());
assertEquals(15, h.premierTick());
assertNull(h.depuis(14)); // plus ancien que l'historique : pas de mesure
double[][] d = h.depuis(40);
assertNotNull(d);
assertEquals(10 + HistoriqueBoites.CAPACITE + 5 - 40, d.length);
assertArrayEquals(boite(40), d[0], 1e-12);
h.ajouter(46, boite(0)); // même tick : remplacé
assertEquals(HistoriqueBoites.CAPACITE, h.taille());
h.ajouter(3, boite(0)); // horloge revenue en arrière : on repart
assertEquals(1, h.taille());
}
@Test
void fenetreBorneeParLePingMax() {
assertEquals(cfg.ticksAffichageCible, PorteeHitbox.ticksFenetre(0, cfg));
assertEquals(cfg.ticksAffichageCible + 3, PorteeHitbox.ticksFenetre(150, cfg));
int max = PorteeHitbox.ticksFenetre(cfg.seriePingMaxMs, cfg);
assertEquals(max, PorteeHitbox.ticksFenetre(100000, cfg));
assertTrue(max + 1 < HistoriqueBoites.CAPACITE);
}
@Test
void serieCoupsOublieLesCoupsTropAnciens() {
SerieCoups s = new SerieCoups();
for (int k = 0; k < 3; k++) s.enregistrer(k * 1000L, true, cfg);
// 4e coup hors boîte, mais les 3 premiers sont hors de la fenêtre de 30 s.
assertEquals(0, s.enregistrer(3 * 1000L + cfg.serieFenetreMs + 1, true, cfg), 1e-9);
assertEquals(1, s.dernierTotal());
}
}