diff --git a/src/test/java/com/gastinelgarde/core/Garde92Test.java b/src/test/java/com/gastinelgarde/core/Garde92Test.java new file mode 100644 index 0000000..745eb6e --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/Garde92Test.java @@ -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 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 coup(long t, EtatJoueur etat, double[] oeil, double[] regard, double xCible, double vitesse, + double[][] vues) { + List 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 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 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 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 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()); + } +}