GastinelGarde #92 : controle coups-hors-boite (historique des boites des cibles)
Le test hitbox/portee de Rednixxu passait sous portee et hitbox : sur une cible qui bouge, la marge vitesse x ticks (plafond 1,0 bloc) noyait tout. Nouveau controle : regard et distance testes contre les boites reellement occupees par la cible pendant la fenetre d affichage (7 ticks + ping), serie de 4 coups hors boite sur 10. OBSERVE par defaut. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
b793282e76
révision
7a5a1c92c8
11 fichiers modifiés
+499
-4
Aucun fichier ne correspond à votre recherche
@@ -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<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 Moteur MOTEUR = new Moteur(CONFIG);
|
||||
private static final Map<UUID, Marques> 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<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. */
|
||||
@@ -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();
|
||||
|
||||
@@ -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(),
|
||||
|
||||
@@ -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<String> PREFIXES_CONTRAPTION;
|
||||
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
|
||||
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);
|
||||
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();
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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],
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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,
|
||||
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<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);
|
||||
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<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;
|
||||
}
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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 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;
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur