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 à :
1 Parent
7a5a1c92c8
révision
937d43d499
1 fichier modifié
+261
@@ -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());
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur