Comparer les révisions
2
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
937d43d499 | |||
|
|
7a5a1c92c8 | |||
Aucun fichier ne correspond à votre recherche
@@ -8,6 +8,8 @@ import com.gastinelgarde.core.EtatVehicule;
|
|||||||
import com.gastinelgarde.core.GardeConfig;
|
import com.gastinelgarde.core.GardeConfig;
|
||||||
import com.gastinelgarde.core.GraceRecul;
|
import com.gastinelgarde.core.GraceRecul;
|
||||||
import com.gastinelgarde.core.GraceTeleport;
|
import com.gastinelgarde.core.GraceTeleport;
|
||||||
|
import com.gastinelgarde.core.HistoriqueBoites;
|
||||||
|
import com.gastinelgarde.core.PorteeHitbox;
|
||||||
import com.gastinelgarde.core.Mode;
|
import com.gastinelgarde.core.Mode;
|
||||||
import com.gastinelgarde.core.Moteur;
|
import com.gastinelgarde.core.Moteur;
|
||||||
import com.gastinelgarde.core.RiptideSuivi;
|
import com.gastinelgarde.core.RiptideSuivi;
|
||||||
@@ -82,8 +84,31 @@ public final class Garde {
|
|||||||
int courantTick = Integer.MIN_VALUE;
|
int courantTick = Integer.MIN_VALUE;
|
||||||
int courantVuTick = Integer.MIN_VALUE;
|
int courantVuTick = Integer.MIN_VALUE;
|
||||||
boolean courantProche;
|
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 GardeConfig CONFIG = new GardeConfig();
|
||||||
private static final Moteur MOTEUR = new Moteur(CONFIG);
|
private static final Moteur MOTEUR = new Moteur(CONFIG);
|
||||||
private static final Map<UUID, Marques> MARQUES = new HashMap<>();
|
private static final Map<UUID, Marques> MARQUES = new HashMap<>();
|
||||||
@@ -136,6 +161,7 @@ public final class Garde {
|
|||||||
traces = null;
|
traces = null;
|
||||||
}
|
}
|
||||||
MARQUES.clear();
|
MARQUES.clear();
|
||||||
|
SUIVIES.clear();
|
||||||
}
|
}
|
||||||
|
|
||||||
public static synchronized void flushTraces() {
|
public static synchronized void flushTraces() {
|
||||||
@@ -170,6 +196,8 @@ public final class Garde {
|
|||||||
m.teleportTick = p.server.getTickCount();
|
m.teleportTick = p.server.getTickCount();
|
||||||
m.mouvementTick = Integer.MIN_VALUE;
|
m.mouvementTick = Integer.MIN_VALUE;
|
||||||
m.vehiculeId = -1;
|
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). */
|
/** 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();
|
if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount();
|
||||||
m.mouvementTick = Integer.MIN_VALUE;
|
m.mouvementTick = Integer.MIN_VALUE;
|
||||||
m.vehiculeId = -1;
|
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. */
|
/** 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});
|
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)
|
Sanction sh = traiter(p, vh); // coup déjà porté : les suivants sont annulés (Moteur.coupsBloques)
|
||||||
if (sh == Sanction.EXPULSION) appliquerSanctionMouvement(p, sh, vh);
|
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.mouvementTick = tick;
|
||||||
m.mouvementX = p.getX();
|
m.mouvementX = p.getX();
|
||||||
|
|||||||
@@ -44,6 +44,7 @@ public final class GardeEvents {
|
|||||||
@SubscribeEvent
|
@SubscribeEvent
|
||||||
public static void onTickPre(ServerTickEvent.Pre event) {
|
public static void onTickPre(ServerTickEvent.Pre event) {
|
||||||
debutTickNs = System.nanoTime();
|
debutTickNs = System.nanoTime();
|
||||||
|
Garde.enregistrerHistoriques(event.getServer()); // #92 : boîtes des cibles possibles
|
||||||
}
|
}
|
||||||
|
|
||||||
@SubscribeEvent
|
@SubscribeEvent
|
||||||
@@ -82,10 +83,14 @@ public final class GardeEvents {
|
|||||||
&& (racine == cible || (!Garde.estContraption(racine) && !SableAcces.surSousNiveau(racine)));
|
&& (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)
|
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));
|
+ 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,
|
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[] {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(),
|
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()) {
|
if (Garde.tracesEnCours()) {
|
||||||
Garde.tracer(new TraceLigne(tick, p.getGameProfile().getName(), "atk", p.getX(), p.getY(), p.getZ(),
|
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.IntValue PING_LATENCE_MAX;
|
||||||
private static final ModConfigSpec.DoubleValue VITESSE_CIBLE_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.ConfigValue<String> PREFIXES_CONTRAPTION;
|
||||||
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
|
private static final ModConfigSpec.IntValue DISTANCE_CONTRAPTION;
|
||||||
private static final ModConfigSpec.ConfigValue<String> BLOCS_COURANT_AIR;
|
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);
|
.defineInRange("vitesseCibleMaxMesure", 1.0, 0.1, 10.0);
|
||||||
b.pop();
|
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");
|
b.push("timer");
|
||||||
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
|
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
|
||||||
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
|
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
|
||||||
@@ -219,6 +246,14 @@ public final class GardeSpec {
|
|||||||
c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get();
|
c.latenceCibleMaxBlocs = LATENCE_CIBLE_MAX.get();
|
||||||
c.pingLatenceMaxMs = PING_LATENCE_MAX.get();
|
c.pingLatenceMaxMs = PING_LATENCE_MAX.get();
|
||||||
c.vitesseCibleMaxMesure = VITESSE_CIBLE_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.graceTeleportTicks = GRACE_TELEPORT.get();
|
||||||
c.graceReculTicks = GRACE_RECUL.get();
|
c.graceReculTicks = GRACE_RECUL.get();
|
||||||
c.graceGelTicks = GRACE_GEL.get();
|
c.graceGelTicks = GRACE_GEL.get();
|
||||||
|
|||||||
@@ -10,6 +10,8 @@ public enum Controle {
|
|||||||
ROTATION("rotation"),
|
ROTATION("rotation"),
|
||||||
PORTEE("portee"),
|
PORTEE("portee"),
|
||||||
HITBOX("hitbox"),
|
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"),
|
TIMER("timer"),
|
||||||
NO_FALL("no-fall"),
|
NO_FALL("no-fall"),
|
||||||
VITESSE("vitesse"),
|
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).
|
* correction de l'interdiction du 15/10, qui empêchait aussi la correction no-fall de d0c001d).
|
||||||
*/
|
*/
|
||||||
public boolean observeParDefaut() {
|
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) {
|
public static Controle parse(String texte) {
|
||||||
|
|||||||
@@ -27,6 +27,13 @@ final class CoupDiffere {
|
|||||||
/** Excédent d'angle killaura (degrés), -1 si non mesuré. */
|
/** Excédent d'angle killaura (degrés), -1 si non mesuré. */
|
||||||
double excedent;
|
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,
|
CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
|
||||||
double distance, double manque, double excedent, boolean porteeHitbox) {
|
double distance, double manque, double excedent, boolean porteeHitbox) {
|
||||||
this.nowMs = nowMs;
|
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. */
|
/** Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. */
|
||||||
void affiner(double[] oeil, double[] regard) {
|
void affiner(double[] oeil, double[] regard) {
|
||||||
|
oeilSuivant = oeil.clone();
|
||||||
|
regardSuivant = regard.clone();
|
||||||
double[] b = boite;
|
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 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],
|
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. */
|
/** Cible plus rapide que ça (blocs/tick : élytres, riptide, téléportation, recul fort) : pas de mesure. */
|
||||||
public double vitesseCibleMaxMesure = 1.0;
|
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 ---
|
// --- Exemptions ---
|
||||||
public int graceTeleportTicks = 40;
|
public int graceTeleportTicks = 40;
|
||||||
public int graceReculTicks = 20;
|
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,
|
public List<Verdict> coupDiffere(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] regard,
|
||||||
double[] boite, double porteeJoueur, double vitesseCible,
|
double[] boite, double porteeJoueur, double vitesseCible,
|
||||||
boolean porteeHitbox, boolean angle) {
|
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);
|
List<Verdict> verdicts = terminerCoup(joueur);
|
||||||
|
boolean serie = porteeHitbox && boitesVues != null && boitesVues.length > 0
|
||||||
|
&& cfg.mode(Controle.COUPS_HORS_BOITE) != Mode.OFF;
|
||||||
boolean ph = porteeHitbox
|
boolean ph = porteeHitbox
|
||||||
&& (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF);
|
&& (cfg.mode(Controle.PORTEE) != Mode.OFF || cfg.mode(Controle.HITBOX) != Mode.OFF);
|
||||||
boolean an = angle && cfg.mode(Controle.KILLAURA_ANGLE) != 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],
|
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;
|
boite[0], boite[1], boite[2], boite[3], boite[4], boite[5]) : -1;
|
||||||
if (an && ex < 0) ex = -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]);
|
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],
|
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]);
|
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;
|
return verdicts;
|
||||||
}
|
}
|
||||||
|
|
||||||
@@ -192,6 +249,7 @@ public final class Moteur {
|
|||||||
if (c.porteeHitbox) {
|
if (c.porteeHitbox) {
|
||||||
verdicts.addAll(porteeHitbox(joueur, c.nowMs, c.etat, c.distance, c.manque, c.porteeJoueur, c.vitesseCible));
|
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
|
for (Verdict v : verdicts) { // le coup est déjà passé : en ENFORCE, on annule les suivants
|
||||||
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
|
if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) {
|
||||||
s.coupsBloquesJusqua = Math.max(s.coupsBloquesJusqua, c.nowMs + DUREE_BLOCAGE_COUPS_MS);
|
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;
|
if (!(manque > seuil)) return 0;
|
||||||
return 1.0 + Math.min(2.0, (manque - seuil) / 0.3);
|
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 VitesseHorizontale vitesse = new VitesseHorizontale();
|
||||||
public final VolVertical vol = new VolVertical();
|
public final VolVertical vol = new VolVertical();
|
||||||
public final VehiculeMouvement vehicule = new VehiculeMouvement();
|
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}). */
|
/** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */
|
||||||
CoupDiffere coupDiffere;
|
CoupDiffere coupDiffere;
|
||||||
|
|||||||
@@ -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