diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index e2b9028..9ca5d73 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -8,6 +8,8 @@ import com.gastinelgarde.core.EtatVehicule; import com.gastinelgarde.core.GardeConfig; import com.gastinelgarde.core.GraceRecul; import com.gastinelgarde.core.GraceTeleport; +import com.gastinelgarde.core.HistoriqueBoites; +import com.gastinelgarde.core.PorteeHitbox; import com.gastinelgarde.core.Mode; import com.gastinelgarde.core.Moteur; import com.gastinelgarde.core.RiptideSuivi; @@ -82,8 +84,31 @@ public final class Garde { int courantTick = Integer.MIN_VALUE; int courantVuTick = Integer.MIN_VALUE; boolean courantProche; + // #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux) + double[] oeilDernier; + double[] oeilAvant; } + /** #92 : historique des boîtes d'une entité suivie (joueurs, et entités frappées récemment). */ + private static final class Suivie { + final Entity entite; + final HistoriqueBoites historique = new HistoriqueBoites(); + net.minecraft.world.level.Level niveau; + int jusquaTick; + + Suivie(Entity e) { + this.entite = e; + this.niveau = e.level(); + } + } + + /** Entités dont on garde les boîtes, par identifiant (unique sur le serveur). */ + private static final Map SUIVIES = new HashMap<>(); + /** Une entité non joueur frappée est suivie pendant 10 s après le dernier coup. */ + private static final int SUIVI_ENTITE_TICKS = 200; + /** Garde-fou mémoire : au plus ce nombre d'entités non joueur suivies. */ + private static final int SUIVIES_MAX = 256; + private static final GardeConfig CONFIG = new GardeConfig(); private static final Moteur MOTEUR = new Moteur(CONFIG); private static final Map MARQUES = new HashMap<>(); @@ -136,6 +161,7 @@ public final class Garde { traces = null; } MARQUES.clear(); + SUIVIES.clear(); } public static synchronized void flushTraces() { @@ -170,6 +196,8 @@ public final class Garde { m.teleportTick = p.server.getTickCount(); m.mouvementTick = Integer.MIN_VALUE; m.vehiculeId = -1; + m.oeilAvant = null; + m.oeilDernier = null; } /** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */ @@ -188,6 +216,92 @@ public final class Garde { if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount(); m.mouvementTick = Integer.MIN_VALUE; m.vehiculeId = -1; + m.oeilAvant = null; + m.oeilDernier = null; + } + + // --- Historique des cibles (#92, contrôle coups-hors-boite) --- + + /** + * Début de tick (après les paquets reçus entre deux ticks, avant l'envoi des positions aux clients) : boîte de + * chaque joueur et de chaque entité frappée récemment. C'est ce que les clients vont recevoir pendant ce tick. + * Coût : quelques joueurs et quelques mobs, 6 doubles chacun. + */ + public static void enregistrerHistoriques(MinecraftServer server) { + if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) { + if (!SUIVIES.isEmpty()) SUIVIES.clear(); + return; + } + int tick = server.getTickCount(); + for (ServerPlayer p : server.getPlayerList().getPlayers()) { + Suivie s = SUIVIES.get(p.getId()); + if (s == null || s.entite != p) { + s = new Suivie(p); // connexion, ou réapparition (nouvel objet joueur, même identifiant) + SUIVIES.put(p.getId(), s); + } + s.jusquaTick = tick + SUIVI_ENTITE_TICKS; + } + java.util.Iterator> it = SUIVIES.entrySet().iterator(); + while (it.hasNext()) { + Suivie s = it.next().getValue(); + Entity e = s.entite; + if (e.isRemoved() || tick > s.jusquaTick) { + it.remove(); + continue; + } + if (e.level() != s.niveau) { // changement de dimension : les anciennes boîtes ne veulent plus rien dire + s.historique.vider(); + s.niveau = e.level(); + } + net.minecraft.world.phys.AABB b = boiteVisee(e); + s.historique.ajouter(tick, b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ); + } + } + + /** Boîte que le client vise (vanilla : boîte gonflée du rayon de visée de l'entité, 0 pour presque toutes). */ + static net.minecraft.world.phys.AABB boiteVisee(Entity e) { + float r = e.getPickRadius(); + return r > 0 ? e.getBoundingBox().inflate(r) : e.getBoundingBox(); + } + + /** + * Boîtes de la cible sur la fenêtre où l'attaquant a pu la voir (selon son ping), ou null si l'historique ne + * couvre pas toute la fenêtre (entité jamais frappée jusque-là, connexion récente) : on ne mesure pas. + * Une entité non joueur frappée commence ici à être suivie. + */ + public static double[][] boitesVues(Entity cible, ServerPlayer attaquant, int tick) { + if (CONFIG.mode(Controle.COUPS_HORS_BOITE) == Mode.OFF) return null; + Suivie s = SUIVIES.get(cible.getId()); + if (s == null || s.entite != cible) { + if (!(cible instanceof Player) && SUIVIES.size() < SUIVIES_MAX) { + s = new Suivie(cible); + s.jusquaTick = tick + SUIVI_ENTITE_TICKS; + SUIVIES.put(cible.getId(), s); + } + return null; + } + if (!(cible instanceof Player)) s.jusquaTick = tick + SUIVI_ENTITE_TICKS; + if (s.niveau != cible.level()) return null; + int fenetre = PorteeHitbox.ticksFenetre(attaquant.connection.latency(), CONFIG); + return s.historique.depuis(tick - fenetre); + } + + /** Œil de l'attaquant au paquet de mouvement d'avant le dernier (null si inconnu). */ + public static double[] oeilAvant(ServerPlayer p) { + Marques m = MARQUES.get(p.getUUID()); + return m == null ? null : m.oeilAvant; + } + + /** + * La cible est-elle sur ou près d'une contraption Create / d'un vaisseau Sable ? Sa position affichée chez les + * autres clients peut alors suivre la contraption autrement que ses positions serveur : on ne mesure pas. + */ + public static boolean cibleProcheContraption(Entity cible, int tick) { + if (cible instanceof ServerPlayer j) return pocheContraptionEnCache(j, marques(j.getUUID()), tick); + if (SableAcces.surSousNiveau(cible)) return true; + int dist = GardeSpec.distanceContraption(); + if (dist <= 0) return false; + return !cible.level().getEntities(cible, cible.getBoundingBox().inflate(dist), Garde::estContraption).isEmpty(); } /** Recul réel (F06). Auto-infligé (charge de vent à ses pieds) : grâce limitée, voir GraceRecul. */ @@ -476,6 +590,9 @@ public final class Garde { new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z}); Sanction sh = traiter(p, vh); // coup déjà porté : les suivants sont annulés (Moteur.coupsBloques) if (sh == Sanction.EXPULSION) appliquerSanctionMouvement(p, sh, vh); + // #92 : œil des deux derniers paquets, pour le prochain coup. + m.oeilAvant = m.oeilDernier; + m.oeilDernier = new double[] {oeil.x, oeil.y, oeil.z}; } m.mouvementTick = tick; m.mouvementX = p.getX(); diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index 2a7ef1c..ff206d9 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -44,6 +44,7 @@ public final class GardeEvents { @SubscribeEvent public static void onTickPre(ServerTickEvent.Pre event) { debutTickNs = System.nanoTime(); + Garde.enregistrerHistoriques(event.getServer()); // #92 : boîtes des cibles possibles } @SubscribeEvent @@ -82,10 +83,14 @@ public final class GardeEvents { && (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine))); double vitesseCible = Math.sqrt(Math.pow(cible.getX() - cible.xo, 2) + Math.pow(cible.getY() - cible.yo, 2) + Math.pow(cible.getZ() - cible.zo, 2)); + // #92 (cas de Rednixxu) : boîtes de la cible sur la fenêtre où le client a pu la voir, au lieu d'une marge + // « vitesse × ticks » dans toutes les directions. Null (pas de mesure) si l'historique est incomplet ou si + // la cible est sur ou près d'une contraption / d'un vaisseau. + double[][] vues = mesurerPH && !Garde.cibleProcheContraption(cible, tick) ? Garde.boitesVues(cible, p, tick) : null; verdicts.addAll(Garde.moteur().coupDiffere(p.getUUID(), tick * 50L, etat, new double[] {oeil.x, oeil.y, oeil.z}, new double[] {regard.x, regard.y, regard.z}, new double[] {bb.minX, bb.minY, bb.minZ, bb.maxX, bb.maxY, bb.maxZ}, p.entityInteractionRange(), - vitesseCible, mesurerPH, true)); + vitesseCible, mesurerPH, true, Garde.oeilAvant(p), vues)); if (Garde.tracesEnCours()) { Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(), diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index 3e8428f..d8cdfd2 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -47,6 +47,15 @@ public final class GardeSpec { private static final ModConfigSpec.IntValue PING_LATENCE_MAX; private static final ModConfigSpec.DoubleValue VITESSE_CIBLE_MAX; + private static final ModConfigSpec.IntValue TICKS_AFFICHAGE; + private static final ModConfigSpec.IntValue SERIE_PING_MAX; + private static final ModConfigSpec.DoubleValue SERIE_MANQUE; + private static final ModConfigSpec.DoubleValue SERIE_PORTEE; + private static final ModConfigSpec.IntValue SERIE_COUPS; + private static final ModConfigSpec.IntValue SERIE_HORS_MIN; + private static final ModConfigSpec.IntValue SERIE_FENETRE_MS; + private static final ModConfigSpec.DoubleValue SERIE_POINTS; + private static final ModConfigSpec.ConfigValue PREFIXES_CONTRAPTION; private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION; private static final ModConfigSpec.ConfigValue BLOCS_COURANT_AIR; @@ -110,6 +119,24 @@ public final class GardeSpec { .defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0); b.pop(); + b.comment("Contrôle coups-hors-boite (#92) : le regard est testé contre toutes les positions où le client a pu", + "voir la cible (historique des boîtes), au lieu d'une marge « vitesse × ticks » dans toutes les directions.", + "Un coup isolé ne compte pas : seulement une série (serieHorsMin coups hors boîte sur les serieCoups derniers).", + "Valeurs de départ prudentes, à régler avec les journaux en OBSERVE avant tout ENFORCE.").push("coupsHorsBoite"); + TICKS_AFFICHAGE = b.comment("Retard d'affichage de base de la cible chez le client (ticks) ; le ping s'ajoute (ping / 50).") + .defineInRange("ticksAffichageCible", 7, 2, 12); + SERIE_PING_MAX = b.comment("Ping (ms) au-delà duquel le coup n'est pas mesuré.") + .defineInRange("seriePingMaxMs", 500, 100, 500); + SERIE_MANQUE = b.comment("Coup hors boîte si le regard manque toutes les boîtes vues de plus de cette marge (blocs).") + .defineInRange("serieManqueBlocs", 0.15, 0.05, 2.0); + SERIE_PORTEE = b.comment("... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs).") + .defineInRange("seriePorteeMargeBlocs", 0.15, 0.05, 2.0); + SERIE_COUPS = b.defineInRange("serieCoups", 10, 3, 32); + SERIE_HORS_MIN = b.defineInRange("serieHorsMin", 4, 2, 32); + SERIE_FENETRE_MS = b.defineInRange("serieFenetreMs", 30000, 1000, 600000); + SERIE_POINTS = b.defineInRange("seriePoints", 2.0, 0.1, 20.0); + b.pop(); + b.push("timer"); PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200); TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30); @@ -219,6 +246,14 @@ public final class GardeSpec { c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get(); c.pingLatenceMaxMs = PING_LATENCE_MAX.get(); c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get(); + c.ticksAffichageCible = TICKS_AFFICHAGE.get(); + c.seriePingMaxMs = SERIE_PING_MAX.get(); + c.serieManqueBlocs = SERIE_MANQUE.get(); + c.seriePorteeMargeBlocs = SERIE_PORTEE.get(); + c.serieCoups = SERIE_COUPS.get(); + c.serieHorsMin = Math.min(SERIE_HORS_MIN.get(), c.serieCoups); + c.serieFenetreMs = SERIE_FENETRE_MS.get(); + c.seriePoints = SERIE_POINTS.get(); c.graceTeleportTicks = GRACE_TELEPORT.get(); c.graceReculTicks = GRACE_RECUL.get(); c.graceGelTicks = GRACE_GEL.get(); diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index 3d32b15..73fca76 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -10,6 +10,8 @@ public enum Controle { ROTATION("rotation"), PORTEE("portee"), HITBOX("hitbox"), + /** #92 : série de coups qui manquent toutes les positions où la cible a pu être vue (hitbox, reach). */ + COUPS_HORS_BOITE("coups-hors-boite"), TIMER("timer"), NO_FALL("no-fall"), VITESSE("vitesse"), @@ -33,7 +35,8 @@ public enum Controle { * correction de l'interdiction du 15/10, qui empêchait aussi la correction no-fall de d0c001d). */ public boolean observeParDefaut() { - return this == NO_FALL || this == VITESSE || this == VOL || this == PORTEE || this == HITBOX; + return this == NO_FALL || this == VITESSE || this == VOL || this == PORTEE || this == HITBOX + || this == COUPS_HORS_BOITE; } public static Controle parse(String texte) { diff --git a/src/main/java/com/gastinelgarde/core/CoupDiffere.java b/src/main/java/com/gastinelgarde/core/CoupDiffere.java index 2b901dc..be4a7d5 100644 --- a/src/main/java/com/gastinelgarde/core/CoupDiffere.java +++ b/src/main/java/com/gastinelgarde/core/CoupDiffere.java @@ -27,6 +27,13 @@ final class CoupDiffere { /** Excédent d'angle killaura (degrés), -1 si non mesuré. */ double excedent; + // #92 : mesure compensée par l'historique de la cible (contrôle coups-hors-boite). Null : pas d'historique. + double[][] boitesVues; + /** Œil au paquet d'avant, au coup, au paquet suivant (null si inconnu). */ + double[] oeilPrecedent, oeilCoup, oeilSuivant; + /** Regard au coup et au paquet suivant (null si inconnu). */ + double[] regardCoup, regardSuivant; + CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible, double distance, double manque, double excedent, boolean porteeHitbox) { this.nowMs = nowMs; @@ -47,6 +54,8 @@ final class CoupDiffere { /** Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. */ void affiner(double[] oeil, double[] regard) { + oeilSuivant = oeil.clone(); + regardSuivant = regard.clone(); double[] b = boite; double d = PorteeHitbox.distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5]); double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2], diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index 804fe76..d6ccff1 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -58,6 +58,27 @@ public final class GardeConfig { /** Cible plus rapide que ça (blocs/tick : élytres, riptide, téléportation, recul fort) : pas de mesure. */ public double vitesseCibleMaxMesure = 1.0; + // --- Coups hors boîte (#92, 16/10 : le cas de Rednixxu passait sous portee et hitbox) --- + /** + * Retard d'affichage de base de la cible chez le client (ticks) : envoi de sa position toutes les 2 (joueur) à + * 3 ticks (mob), interpolation sur 3 ticks, plus 1 tick de gigue. Le ping s'ajoute (voir seriePingMaxMs). + */ + public int ticksAffichageCible = 7; + /** Ping (ms) au-delà duquel la mesure compensée n'est pas faite (fenêtre plus large que l'historique fiable). */ + public int seriePingMaxMs = 500; + /** Un coup est « hors boîte » si le regard manque toutes les boîtes vues de plus de cette marge (blocs). */ + public double serieManqueBlocs = 0.15; + /** ... ou si toutes les boîtes vues étaient au-delà de la portée d'interaction + cette marge (blocs). */ + public double seriePorteeMargeBlocs = 0.15; + /** Nombre de derniers coups mesurés examinés. */ + public int serieCoups = 10; + /** Coups hors boîte, parmi les serieCoups derniers, à partir desquels un coup hors boîte compte. */ + public int serieHorsMin = 4; + /** Âge maximal (ms) d'un coup encore compté dans la série. */ + public long serieFenetreMs = 30000; + /** Points par coup hors boîte dans une série suspecte. */ + public double seriePoints = 2.0; + // --- Exemptions --- public int graceTeleportTicks = 40; public int graceReculTicks = 20; diff --git a/src/main/java/com/gastinelgarde/core/HistoriqueBoites.java b/src/main/java/com/gastinelgarde/core/HistoriqueBoites.java new file mode 100644 index 0000000..ced1a1b --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/HistoriqueBoites.java @@ -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; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index d2136b9..a3d9815 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -149,11 +149,29 @@ public final class Moteur { public List coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard, double[] boite, double porteeJoueur, double vitesseCible, boolean porteeHitbox, boolean angle) { + return coupDiffere(joueur, nowMs, etat, oeil, regard, boite, porteeJoueur, vitesseCible, porteeHitbox, angle, + null, null); + } + + /** + * Idem, avec ce qu'il faut pour la mesure compensée du contrôle coups-hors-boite (#92). + * + * @param oeilPrecedent œil au paquet de mouvement d'avant le dernier (null si inconnu) + * @param boitesVues boîtes de la cible sur la fenêtre où le client a pu la voir, dans l'ordre chronologique + * (voir {@link HistoriqueBoites#depuis} et {@link PorteeHitbox#ticksFenetre}) ; null si + * l'historique est incomplet : le contrôle ne mesure pas ce coup + */ + public List 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 verdicts = terminerCoup(joueur); + boolean serie = porteeHitbox && boitesVues != null && boitesVues.length > 0 + && cfg.mode(Controle.COUPS_HORS_BOITE) != Mode.OFF; boolean ph = porteeHitbox && (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF); boolean an = angle && cfg.mode(Controle.KILLAURA_ANGLE) != Mode.OFF; - if (!ph && !an) return verdicts; + if (!ph && !an && !serie) return verdicts; double ex = an ? KillauraAngle.excedentDegres(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2], boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]) : -1; if (an && ex < 0) ex = -1; @@ -161,7 +179,46 @@ public final class Moteur { boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]); double m = PorteeHitbox.manqueRegard(oeil[0], oeil[1], oeil[2], regard[0], regard[1], regard[2], porteeJoueur + 1.0, boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]); - suivi(joueur).coupDiffere = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph); + CoupDiffere c = new CoupDiffere(nowMs, etat, boite.clone(), porteeJoueur, vitesseCible, d, m, ex, ph); + if (serie) { + c.boitesVues = boitesVues; + c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone(); + c.oeilCoup = oeil.clone(); + c.regardCoup = regard.clone(); + } + suivi(joueur).coupDiffere = c; + return verdicts; + } + + /** + * Contrôle coups-hors-boite (#92) : mesure compensée du coup (toutes les positions où la cible a pu être vue, + * tous les yeux et regards plausibles de l'attaquant), puis série sur les derniers coups. + */ + private List 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 verdicts = new ArrayList<>(1); + ajouter(verdicts, s, Controle.COUPS_HORS_BOITE, pts, c.nowMs, ex, String.format(Locale.ROOT, + "manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d", + m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal())); return verdicts; } @@ -192,6 +249,7 @@ public final class Moteur { if (c.porteeHitbox) { verdicts.addAll(porteeHitbox(joueur, c.nowMs, c.etat, c.distance, c.manque, c.porteeJoueur, c.vitesseCible)); } + verdicts.addAll(coupsHorsBoite(s, c)); for (Verdict v : verdicts) { // le coup est déjà passé : en ENFORCE, on annule les suivants if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) { s.coupsBloquesJusqua = Math.max(s.coupsBloquesJusqua, c.nowMs + DUREE_BLOCAGE_COUPS_MS); diff --git a/src/main/java/com/gastinelgarde/core/PorteeHitbox.java b/src/main/java/com/gastinelgarde/core/PorteeHitbox.java index 938c602..53de2ff 100644 --- a/src/main/java/com/gastinelgarde/core/PorteeHitbox.java +++ b/src/main/java/com/gastinelgarde/core/PorteeHitbox.java @@ -126,4 +126,93 @@ public final class PorteeHitbox { if (!(manque > seuil)) return 0; return 1.0 + Math.min(2.0, (manque - seuil) / 0.3); } + + // --- Mesure compensée par l'historique de la cible (#92, contrôle coups-hors-boite) ---------------------- + + /** + * Écart maximal (en entrées d'historique) entre deux boîtes réunies : la cible affichée est interpolée en + * ligne droite entre deux positions reçues, espacées de 2 ticks (joueur) à 3 ticks (mob) ; la boîte englobante + * de deux boîtes contient tout le segment qui les relie. + */ + public static final int ECART_REUNION_MAX = 3; + + /** + * Mesure compensée. + * + * @param distance distance minimale œil – boîte, sur tous les yeux et toutes les boîtes candidates + * @param manque gonflement minimal pour que l'un des regards touche l'une des boîtes candidates + * @param deplacementMax plus grand déplacement de la cible d'une entrée d'historique à la suivante (blocs) + */ + public record Mesure(double distance, double manque, double deplacementMax) { } + + /** + * Fenêtre d'historique (ticks) où le client a pu voir la cible : retard d'affichage de base, plus le ping + * (aller-retour : la position part vers l'attaquant, le coup revient), borné. + */ + public static int ticksFenetre(int pingMs, GardeConfig cfg) { + int ping = Math.min(Math.max(0, pingMs), Math.max(0, cfg.seriePingMaxMs)); + return Math.max(0, cfg.ticksAffichageCible) + (int) Math.ceil(ping / 50.0); + } + + /** + * Distance et manque minimaux sur toutes les combinaisons (œil, regard, boîte candidate). Boîtes candidates : + * chaque boîte de l'historique, et la boîte englobante de deux boîtes distantes d'au plus + * {@link #ECART_REUNION_MAX} entrées (position interpolée entre les deux), sauf si la cible a « sauté » plus + * de {@code sautMax} blocs par entrée entre elles (téléportation : pas d'interpolation). + * + * Toutes les sources d'écart honnêtes sont prises du côté favorable au joueur : œil précédent, actuel et + * suivant (le client vise depuis une position interpolée entre deux paquets), regard actuel et suivant. + */ + public static Mesure mesureCompensee(double[][] yeux, double[][] regards, double[][] boites, double longueur, + double sautMax) { + double distance = Double.MAX_VALUE; + double manque = MANQUE_MAX; + double deplacementMax = 0; + for (int i = 1; i < boites.length; i++) deplacementMax = Math.max(deplacementMax, ecartCentres(boites[i - 1], boites[i])); + for (int i = 0; i < boites.length; i++) { + for (int k = 0; k <= ECART_REUNION_MAX && i + k < boites.length; k++) { + double[] b; + if (k == 0) { + b = boites[i]; + } else { + if (ecartCentres(boites[i], boites[i + k]) > sautMax * k) continue; + b = reunion(boites[i], boites[i + k]); + } + for (double[] oeil : yeux) { + if (oeil == null) continue; + distance = Math.min(distance, distanceOeilBoite(oeil[0], oeil[1], oeil[2], b[0], b[1], b[2], b[3], b[4], b[5])); + for (double[] r : regards) { + if (r == null || manque == 0) continue; + manque = Math.min(manque, manqueRegard(oeil[0], oeil[1], oeil[2], r[0], r[1], r[2], longueur, + b[0], b[1], b[2], b[3], b[4], b[5])); + } + } + } + } + if (distance == Double.MAX_VALUE) distance = 0; + return new Mesure(distance, manque, deplacementMax); + } + + static double ecartCentres(double[] a, double[] b) { + double dx = (a[0] + a[3] - b[0] - b[3]) / 2, dy = (a[1] + a[4] - b[1] - b[4]) / 2, dz = (a[2] + a[5] - b[2] - b[5]) / 2; + return Math.sqrt(dx * dx + dy * dy + dz * dz); + } + + static double[] reunion(double[] a, double[] b) { + return new double[] {Math.min(a[0], b[0]), Math.min(a[1], b[1]), Math.min(a[2], b[2]), + Math.max(a[3], b[3]), Math.max(a[4], b[4]), Math.max(a[5], b[5])}; + } + + /** + * Situations où la mesure compensée n'est pas fiable (en plus de {@link #raisonNonMesure}, sans la vitesse + * instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées), ping au-delà + * de {@link GardeConfig#seriePingMaxMs} (la fenêtre ne couvrirait plus le retard d'affichage). + */ + public static String raisonNonMesureSerie(EtatJoueur e, GardeConfig cfg) { + String r = raisonNonMesure(e, 0, cfg); + if (r != null) return r; + if (e.ticksDepuisGel() <= cfg.graceGelTicks) return "gel-serveur"; + if (e.pingMs() > cfg.seriePingMaxMs) return "ping"; + return null; + } } diff --git a/src/main/java/com/gastinelgarde/core/SerieCoups.java b/src/main/java/com/gastinelgarde/core/SerieCoups.java new file mode 100644 index 0000000..d2d2a80 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/SerieCoups.java @@ -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; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index ffde619..49d20da 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -14,6 +14,8 @@ public final class Suivi { public final VitesseHorizontale vitesse = new VitesseHorizontale(); public final VolVertical vol = new VolVertical(); public final VehiculeMouvement vehicule = new VehiculeMouvement(); + /** #92 : derniers coups mesurés avec l'historique de la cible (contrôle coups-hors-boite). */ + public final SerieCoups serie = new SerieCoups(); /** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */ CoupDiffere coupDiffere;