GastinelGarde : correctif coups-hors-boite (revue 1-4), C13, C10, C15

- revue 1 : ping > seriePingMaxMs n'exempte plus, fenetre bornee
- revue 2 / C13 : oeil suivant borne a un tick de deplacement ; regard suivant > 90 deg refuse
  par coups-hors-boite, serie de coups sauves par le regard suivant comptee en killaura-angle
- revue 3 : table SUIVIES pleine -> eviction de la cible frappee le plus anciennement
- revue 4 : fenetre selon le ping plancher des 2 dernieres minutes + 50 ms (PingPlancher)
- C10 (option volFenetreGlissante, desactivee) : fenetre glissante + sauts en l'air repetes
- C15 (options vitesseMoyenne, timerSoldeMax, desactivees) : vitesse moyenne, solde timer
Temoins modifies (a valider) : Garde92Test ping, revue 4 (cible 4,2), C13 angle en serie.
cornafserver : 254 tests, 0 echec.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Opus 5.5 a révisé 2026-10-16 06:11:21 +02:00
1 Parent 080415c646
révision 4776895371
12 fichiers modifiés
+340 -31

Aucun fichier ne correspond à votre recherche

+26 -2
Voir le fichier
@@ -240,6 +240,8 @@ public final class Garde {
SUIVIES.put(p.getId(), s);
}
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
// Revue 4 (16/10) : ping noté chaque seconde, hors combat aussi, pour le plancher de ping.
if (tick % 20 == 0) MOTEUR.pingFenetre(p.getUUID(), tick * 50L, p.connection.latency());
}
java.util.Iterator<Map.Entry<Integer, Suivie>> it = SUIVIES.entrySet().iterator();
while (it.hasNext()) {
@@ -273,7 +275,11 @@ public final class Garde {
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) {
if (!(cible instanceof Player)) {
// Revue 3 (16/10) : table pleine, on évince la cible non joueur frappée il y a le plus longtemps
// (avant : la nouvelle cible n'était jamais suivie, faire frapper beaucoup d'entités aveuglait le
// contrôle). La cible qu'on frappe sans arrêt est la plus récente : jamais évincée.
if (s == null && SUIVIES.size() >= SUIVIES_MAX) evincerPlusAncienne();
s = new Suivie(cible);
s.jusquaTick = tick + SUIVI_ENTITE_TICKS;
SUIVIES.put(cible.getId(), s);
@@ -282,10 +288,28 @@ public final class Garde {
}
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);
// Revue 4 (16/10) : ping plancher des 2 dernières minutes + marge, pas le ping déclaré du moment.
int fenetre = PorteeHitbox.ticksFenetre(
MOTEUR.pingFenetre(attaquant.getUUID(), tick * 50L, attaquant.connection.latency()), CONFIG);
return s.historique.depuis(tick - fenetre);
}
/** Revue 3 : retire de la table l'entrée non joueur dont le dernier coup est le plus ancien. */
private static void evincerPlusAncienne() {
Integer cle = null;
int plusTot = Integer.MAX_VALUE;
for (Map.Entry<Integer, Suivie> e : SUIVIES.entrySet()) {
Suivie v = e.getValue();
if (v != null && v.entite instanceof Player) continue;
int t = v == null ? Integer.MIN_VALUE : v.jusquaTick;
if (cle == null || t < plusTot) {
cle = e.getKey();
plusTot = t;
}
}
if (cle != null) SUIVIES.remove(cle);
}
/** Œ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());
+64 -4
Voir le fichier
@@ -15,6 +15,24 @@ final class CoupDiffere {
/** Le paquet de mouvement du même tick arrive normalement juste après ; 2 ticks de marge pour la gigue. */
static final int TICKS_MAX = 2;
/**
* Revue 2 / C13 (16/10) : au-delà de cet angle entre le regard du coup et celui du paquet suivant (rotation
* silencieuse : regard ailleurs au coup, ramené sur la cible juste après), le regard suivant n'est plus pris par
* coups-hors-boite, et le coup est compté comme « sauvé par le regard suivant » pour l'angle killaura (série, voir
* {@link Suivi#regardsSauves}). Un coup isolé garde le bénéfice du doute (demi-tour honnête possible).
* [À VÉRIFIER] en jeu : 90° couvre un « flick » honnête.
*/
static final double REGARD_SUIVANT_MAX_DEGRES = 90.0;
/**
* Revue 2 / C13 : l'œil du paquet suivant est ramené à au plus un tick de déplacement de l'œil du coup :
* déplacement horizontal du tick précédent + cette marge (accélération, élan d'un saut en courant)...
*/
static final double OEIL_SUIVANT_MARGE_H = 0.4;
/** ... déplacement vertical du tick précédent + cette marge (saut : 0,42)... */
static final double OEIL_SUIVANT_MARGE_V = 0.5;
/** ... ou, sans œil précédent connu, ce déplacement (horizontal et vertical). */
static final double OEIL_SUIVANT_DEFAUT = 0.6;
final long nowMs;
final EtatJoueur etat;
final double[] boite;
@@ -34,6 +52,11 @@ final class CoupDiffere {
/** Regard au coup et au paquet suivant (null si inconnu). */
double[] regardCoup, regardSuivant;
/** Le regard du paquet suivant a été refusé (trop loin du regard du coup). */
boolean regardSuivantRefuse;
/** Excédent d'angle killaura avec le regard du coup seul (avant affinage), -1 si non mesuré. */
double excedentCoup = -1;
CoupDiffere(long nowMs, EtatJoueur etat, double[] boite, double porteeJoueur, double vitesseCible,
double distance, double manque, double excedent, boolean porteeHitbox) {
this.nowMs = nowMs;
@@ -52,10 +75,18 @@ final class CoupDiffere {
return d >= 0 && d <= TICKS_MAX;
}
/** 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();
/**
* Refait la mesure avec l'œil et le regard du paquet suivant ; garde la plus petite. Revue 2 / C13 (16/10) : l'œil
* suivant est borné à un tick de déplacement depuis l'œil du coup, et le regard suivant n'est pris que s'il reste
* à moins de {@link #REGARD_SUIVANT_MAX_DEGRES} du regard du coup.
*/
void affiner(double[] oeilRecu, double[] regardRecu) {
double[] oeil = oeilCoup == null ? oeilRecu.clone() : bornerOeil(oeilCoup, oeilPrecedent, oeilRecu);
double[] regard = regardRecu.clone();
regardSuivantRefuse = regardCoup != null && !regardAdmis(regardCoup, regardRecu);
excedentCoup = excedent;
oeilSuivant = oeil;
regardSuivant = regardSuivantRefuse ? null : regard;
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],
@@ -68,4 +99,33 @@ final class CoupDiffere {
if (a >= 0) excedent = Math.min(excedent, a);
}
}
/** Le regard suivant est-il à moins de {@link #REGARD_SUIVANT_MAX_DEGRES} du regard du coup ? */
static boolean regardAdmis(double[] coup, double[] suivant) {
double n1 = Math.sqrt(coup[0] * coup[0] + coup[1] * coup[1] + coup[2] * coup[2]);
double n2 = Math.sqrt(suivant[0] * suivant[0] + suivant[1] * suivant[1] + suivant[2] * suivant[2]);
if (n1 < 1e-9 || n2 < 1e-9) return true;
double c = (coup[0] * suivant[0] + coup[1] * suivant[1] + coup[2] * suivant[2]) / (n1 * n2);
return c >= Math.cos(Math.toRadians(REGARD_SUIVANT_MAX_DEGRES)) - 1e-9;
}
/** Œil suivant ramené à un tick de déplacement de l'œil du coup (horizontal et vertical à part). */
static double[] bornerOeil(double[] coup, double[] precedent, double[] suivant) {
double bornH, bornV;
if (precedent == null) {
bornH = OEIL_SUIVANT_DEFAUT;
bornV = OEIL_SUIVANT_DEFAUT;
} else {
bornH = Math.hypot(coup[0] - precedent[0], coup[2] - precedent[2]) + OEIL_SUIVANT_MARGE_H;
bornV = Math.abs(coup[1] - precedent[1]) + OEIL_SUIVANT_MARGE_V;
}
double dx = suivant[0] - coup[0], dz = suivant[2] - coup[2], dy = suivant[1] - coup[1];
double h = Math.hypot(dx, dz);
if (h > bornH) {
dx *= bornH / h;
dz *= bornH / h;
}
if (Math.abs(dy) > bornV) dy = Math.copySign(bornV, dy);
return new double[] {coup[0] + dx, coup[1] + dy, coup[2] + dz};
}
}
+2 -2
Voir le fichier
@@ -72,7 +72,7 @@ public final class GardeConfig {
* 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). */
/** Ping (ms) pris en compte au plus dans la fenêtre (revue 1, 16/10 : au-delà, mesuré quand même, fenêtre bornée). */
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;
@@ -90,7 +90,7 @@ public final class GardeConfig {
* Revue 4 (16/10) : la fenêtre d'historique suit le ping le plus bas vu ces 2 dernières minutes, plus cette marge
* (ms), et non le ping déclaré : gonfler son ping pendant un combat n'élargit plus la fenêtre.
*/
public int seriePingMargeMs = 100;
public int seriePingMargeMs = 50;
// --- C10 / C15 (16/10) : détections supplémentaires, DÉSACTIVÉES par défaut (à valider en OBSERVE) ---
/** C10 : vol, ticks anormaux comptés sur une fenêtre glissante et sauts en l'air sans appui. */
+20 -9
Voir le fichier
@@ -185,12 +185,11 @@ public final class Moteur {
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]);
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();
}
// Revue 2 / C13 : œil et regard du coup gardés dans tous les cas, pour borner ceux du paquet suivant.
c.oeilPrecedent = oeilPrecedent == null ? null : oeilPrecedent.clone();
c.oeilCoup = oeil.clone();
c.regardCoup = regard.clone();
if (serie) c.boitesVues = boitesVues;
suivi(joueur).coupDiffere = c;
return verdicts;
}
@@ -222,8 +221,9 @@ public final class Moteur {
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()));
"manque=%.2f (seuil %.2f) distance=%.2f (seuil %.2f), %d coups hors boite sur %d%s",
m.manque(), seuilManque, m.distance(), seuilPortee, s.serie.dernierCompte(), s.serie.dernierTotal(),
c.regardSuivantRefuse ? ", regard suivant refuse" : ""));
return verdicts;
}
@@ -232,7 +232,10 @@ public final class Moteur {
* {@link PorteeHitbox#ticksFenetre}). Note aussi le ping déclaré.
*/
public int pingFenetre(UUID joueur, long nowMs, int pingDeclare) {
return pingDeclare;
Suivi s = suivi(joueur);
int plancher = s.pingPlancher.noter(nowMs, pingDeclare);
long avecMarge = (long) plancher + Math.max(0, cfg.seriePingMargeMs);
return (int) Math.max(0, Math.min(pingDeclare, avecMarge));
}
/** Premier paquet de mouvement après un coup : mesure refaite avec le nouvel œil et le nouveau regard. */
@@ -258,6 +261,12 @@ public final class Moteur {
double seuil = cfg.angleMaxDegres * ex.facteur();
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, KillauraAngle.points(c.excedent, seuil), c.nowMs, ex,
String.format(Locale.ROOT, "excedent=%.1f deg (seuil %.0f, mesure differee)", c.excedent, seuil));
// C13 : coup « sauvé » seulement par un regard suivant à plus de 90° du regard du coup.
boolean sauve = c.regardSuivantRefuse && c.excedentCoup > seuil && !(c.excedent > seuil);
double ptsSauves = s.regardsSauves.enregistrer(c.nowMs, sauve, cfg);
ajouter(verdicts, s, Controle.KILLAURA_ANGLE, ptsSauves, c.nowMs, ex, String.format(Locale.ROOT,
"regard ramene sur la cible au paquet suivant (excedent au coup %.1f deg), %d coups sur %d",
c.excedentCoup, s.regardsSauves.dernierCompte(), s.regardsSauves.dernierTotal()));
}
}
if (c.porteeHitbox) {
@@ -344,6 +353,7 @@ public final class Moteur {
"au sol declare sans bloc dessous pendant une chute");
}
if (vitesse) {
s.vitesse.moyenne = cfg.vitesseMoyenne; // C15, désactivé par défaut
double pts = s.vitesse.enregistrer(m, ex.facteur(), cfg.excesVitesseBlocs);
ajouter(verdicts, s, Controle.VITESSE, pts, nowMs, ex,
String.format(Locale.ROOT, "dxz=%.3f max=%.3f ticks=%d base=%.3f", m.dxz(),
@@ -358,6 +368,7 @@ public final class Moteur {
if (vol && graceElytres) {
s.vol.vider(); // le paquet qui suit la grâce sert de référence
} else if (vol) {
s.vol.fenetreGlissante = cfg.volFenetreGlissante; // C10, désactivé par défaut
double pts = s.vol.enregistrer(m, false);
ajouter(verdicts, s, Controle.VOL, pts, nowMs, ex, String.format(Locale.ROOT, "dy=%.3f en l'air", m.dy()));
}
+43
Voir le fichier
@@ -0,0 +1,43 @@
package com.gastinelgarde.core;
/**
* Revue 4 (16/10/2026) : ping le plus bas vu sur les 2 dernières minutes, par tranches de 10 s.
*
* La fenêtre d'historique de coups-hors-boite suivait le ping déclaré : un client qui gonfle son ping pendant un
* combat (réponses keep-alive retardées) élargissait la fenêtre et cachait un « hitbox » ou un « reach ». Elle suit
* maintenant ce plancher (plus une marge, voir {@link GardeConfig#seriePingMargeMs}) : le ping qui monte d'un coup
* n'élargit plus rien, un ping durablement élevé (plus de 2 minutes) est de nouveau pris en compte.
*
* Coût constant : 12 tranches.
*/
final class PingPlancher {
static final long TRANCHE_MS = 10_000;
static final int TRANCHES = 12;
private final long[] tranche = new long[TRANCHES];
private final int[] min = new int[TRANCHES];
PingPlancher() {
java.util.Arrays.fill(tranche, Long.MIN_VALUE);
}
/** Note le ping déclaré et renvoie le plancher (ce ping s'il n'y a rien d'autre). */
int noter(long nowMs, int ping) {
long t = Math.floorDiv(nowMs, TRANCHE_MS);
int i = (int) Math.floorMod(t, (long) TRANCHES);
if (tranche[i] != t) {
tranche[i] = t;
min[i] = ping;
} else {
min[i] = Math.min(min[i], ping);
}
int plancher = ping;
for (int k = 0; k < TRANCHES; k++) {
if (tranche[k] != Long.MIN_VALUE && t - tranche[k] < TRANCHES && tranche[k] <= t) {
plancher = Math.min(plancher, min[k]);
}
}
return plancher;
}
}
+4 -3
Voir le fichier
@@ -205,14 +205,15 @@ public final class PorteeHitbox {
/**
* 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).
* instantanée de la cible que l'historique remplace) : gel récent du serveur (positions groupées).
*
* Revue 1 (16/10) : un ping au-delà de {@link GardeConfig#seriePingMaxMs} n'exempte plus le coup (le ping est
* falsifiable) ; la fenêtre reste bornée à ce ping par {@link #ticksFenetre}.
*/
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;
}
}
+7
Voir le fichier
@@ -16,6 +16,13 @@ public final class Suivi {
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();
/** Revue 4 (16/10) : ping le plus bas des 2 dernières minutes (fenêtre de coups-hors-boite). */
final PingPlancher pingPlancher = new PingPlancher();
/**
* C13 (16/10) : derniers coups dont l'angle killaura n'était bon que grâce à un regard suivant à plus de 90° du
* regard du coup (rotation silencieuse). Mêmes réglages de série que coups-hors-boite.
*/
public final SerieCoups regardsSauves = new SerieCoups();
/** Coup en attente de son paquet de mouvement (portée / hitbox, voir {@link CoupDiffere}). */
CoupDiffere coupDiffere;
+31
Voir le fichier
@@ -16,7 +16,36 @@ public final class TimerPaquets {
private final CompteurTranches compteur = new CompteurTranches(TRANCHE_MS, SECONDES_MAX * TRANCHES_PAR_SECONDE + 1);
/**
* C15 (16/10) : solde de paquets (reçus - ticks écoulés), option {@link GardeConfig#timerSoldeMax} (0 = désactivé).
* Un timer à 1,09 (21,8 paquets/s) restait sous le seuil de 22 paquets/s ; son solde, lui, grandit sans fin. Le
* crédit accumulé pendant un lag (paquets en retard, puis rafale de rattrapage) est borné à {@link #CREDIT_MAX}.
*/
static final double CREDIT_MAX = 40;
private double solde;
private long dernierMs = Long.MIN_VALUE;
private double solde(long nowMs, GardeConfig cfg, double facteur) {
if (cfg.timerSoldeMax <= 0) return 0;
if (dernierMs == Long.MIN_VALUE) {
dernierMs = nowMs;
solde = 0;
return 0;
}
solde += 1.0 - Math.max(0, nowMs - dernierMs) / (double) TRANCHE_MS;
solde = Math.max(-CREDIT_MAX, solde);
dernierMs = Math.max(dernierMs, nowMs);
double max = cfg.timerSoldeMax * facteur;
if (solde <= max) return 0;
return 1.0 + Math.min(3.0, (solde - max) / 20.0);
}
public double enregistrer(long nowMs, GardeConfig cfg, double facteur) {
double ptsSolde = solde(nowMs, cfg, facteur);
return Math.max(ptsSolde, enregistrerDebit(nowMs, cfg, facteur));
}
private double enregistrerDebit(long nowMs, GardeConfig cfg, double facteur) {
compteur.ajouter(nowMs);
int max = (int) Math.floor(cfg.paquetsParSecondeMax * facteur);
int secondes = Math.min(SECONDES_MAX, Math.max(1, cfg.timerSecondesSoutenues));
@@ -31,5 +60,7 @@ public final class TimerPaquets {
public void vider() {
compteur.vider();
solde = 0;
dernierMs = Long.MIN_VALUE;
}
}
+60 -3
Voir le fichier
@@ -56,6 +56,24 @@ public final class VitesseHorizontale {
private int ticksDepuisSortie = Integer.MAX_VALUE;
private double dernierPermis;
// --- C15 (16/10) : vitesse moyenne, option {@link GardeConfig#vitesseMoyenne} désactivée par défaut ---
/** Fenêtre (paquets) sur laquelle la vitesse moyenne est comparée à la moyenne vanilla. */
public static final int MOYENNE_PAQUETS = 40;
/** Moyenne vanilla en course au sol (0,2806 bloc/tick en régime établi) et en sprint-saut (~0,356, 7,13 m/s). */
public static final double MOYENNE_COURSE_SOL = 0.29;
public static final double MOYENNE_COURSE_AIR = 0.36;
/** Marche : au sol 0,216 ; en l'air (saut en marchant) la base actuelle suffit. */
public static final double MOYENNE_MARCHE_SOL = 0.22;
/** Marge sur la moyenne attendue (arrondis, petites accélérations). [À VÉRIFIER] avec des traces réelles. */
public static final double MOYENNE_MARGE = 0.08;
/** Activé par le moteur selon la configuration. */
boolean moyenne;
private final double[] moyDxz = new double[MOYENNE_PAQUETS];
private final double[] moyAttendu = new double[MOYENNE_PAQUETS];
private int moyIndex;
private int moyRemplis;
/** Vitesse maximale attendue (blocs par tick) pour cet état, avant la tolérance du lag. */
public static double vitesseMax(EtatMouvement e) {
double v;
@@ -84,6 +102,7 @@ public final class VitesseHorizontale {
double base = vitesseMax(e) * facteur;
if (e.milieuSpecial() || e.frictionAnormale()) {
// Glace, eau, échelle… : non contrôlé, mais l'élan qui en sort est légitime.
viderMoyenne();
pousser(0);
memoriser(e.dxz(), base, TRAINEE_AIR);
avancerSortie(ticks);
@@ -105,13 +124,49 @@ public final class VitesseHorizontale {
// Un paquet = un tick du client, même arrivé après 2 ticks serveur : l'élan est son déplacement, borné par le
// permis d'UN tick (sinon un client qui n'envoie qu'un paquet sur deux se construirait un élan).
memoriser(Math.min(e.dxz(), permisParTick), base, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
boolean sortieRecente = ticksDepuisSortie < MOYENNE_PAQUETS;
avancerSortie(ticks);
double ptsMoyenne = moyenne ? moyenne(e, ticks, facteur, sortieRecente) : 0;
if (depasse <= 0) return 0;
if (depasse <= 0) return ptsMoyenne;
double total = 0;
for (double v : exces) total += v;
if (total <= seuilBlocs) return 0;
return 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0);
if (total <= seuilBlocs) return ptsMoyenne;
return Math.max(ptsMoyenne, 1.0 + Math.min(3.0, (total - seuilBlocs) / 2.0));
}
/**
* C15 (16/10) : la base en l'air (0,42 dès que le joueur court) et le tampon de 1,5 bloc sur 20 ticks laissaient
* passer un Speed à 0,37-0,40 bloc/tick sans fin. Ici, la moyenne des {@link #MOYENNE_PAQUETS} derniers paquets est
* comparée à la moyenne vanilla du même état (course au sol, sprint-saut). Pas de mesure juste après un état
* exempté (élan hérité) ni dans un milieu non contrôlé (fenêtre vidée).
*/
private double moyenne(EtatMouvement e, int ticks, double facteur, boolean sortieRecente) {
if (sortieRecente) {
viderMoyenne();
return 0;
}
double base = vitesseMax(e);
double brut;
if (e.furtif() || e.ralentiParObjet()) brut = base; // pas de moyenne connue : la borne actuelle
else if (e.sprint()) brut = base * (e.auSolServeur() ? MOYENNE_COURSE_SOL / COURSE : MOYENNE_COURSE_AIR / COURSE_SAUT);
else brut = e.auSolServeur() ? base * MOYENNE_MARCHE_SOL / MARCHE : base;
moyDxz[moyIndex] = e.dxz();
moyAttendu[moyIndex] = brut * facteur * ticks;
moyIndex = (moyIndex + 1) % MOYENNE_PAQUETS;
if (moyRemplis < MOYENNE_PAQUETS) moyRemplis++;
if (moyRemplis < MOYENNE_PAQUETS) return 0;
double d = 0, a = 0;
for (int i = 0; i < MOYENNE_PAQUETS; i++) {
d += moyDxz[i];
a += moyAttendu[i];
}
return d > a * (1.0 + MOYENNE_MARGE) ? 0.5 : 0;
}
private void viderMoyenne() {
moyIndex = 0;
moyRemplis = 0;
}
/**
@@ -125,6 +180,7 @@ public final class VitesseHorizontale {
public void exempter(EtatMouvement e, double facteur, boolean sortieDEtat) {
java.util.Arrays.fill(exces, 0);
index = 0;
viderMoyenne();
int ticks = Math.max(1, e.ticks());
memoriser(e.dxz(), vitesseMax(e) * facteur, e.auSolServeur() ? TRAINEE_SOL : TRAINEE_AIR);
if (sortieDEtat) ticksDepuisSortie = 0;
@@ -161,5 +217,6 @@ public final class VitesseHorizontale {
aElan = false;
elan = 0;
ticksDepuisSortie = Integer.MAX_VALUE;
viderMoyenne();
}
}
+59
Voir le fichier
@@ -19,6 +19,24 @@ public final class VolVertical {
private boolean etaitEnAir;
private int anormauxConsecutifs;
// --- C10 (16/10) : option {@link GardeConfig#volFenetreGlissante}, désactivée par défaut ---
/** Fenêtre glissante (ticks en l'air évalués) où l'on compte les ticks anormaux. */
public static final int FENETRE_TICKS = 20;
/** Plus de ticks anormaux que ça dans la fenêtre : infraction (alterner 1 anormal / 1 normal en donne 10). */
public static final int FENETRE_ANORMAUX_MAX = 8;
/** Un « saut en l'air » : montée d'au moins ça (blocs) au-dessus de la prévision de gravité, sans appui. */
public static final double SAUT_EN_L_AIR_MIN = 0.2;
/** Deux sauts en l'air à moins de ce nombre de ticks en l'air l'un de l'autre : infraction. */
public static final int SAUTS_FENETRE_TICKS = 60;
/** Activé par le moteur selon la configuration. */
boolean fenetreGlissante;
private final boolean[] fenetre = new boolean[FENETRE_TICKS];
private int fenetreIndex;
private int fenetreAnormaux;
private int ticksEnAir;
private int dernierSautEnAir = Integer.MIN_VALUE;
/** Au-delà, l'écart entre deux paquets est trop grand pour prédire (lag) : on oublie la vitesse. */
public static final int TICKS_MAX = 40;
@@ -44,6 +62,7 @@ public final class VolVertical {
if (exempt || e.milieuSpecial() || !enAir) {
anormauxConsecutifs = 0;
viderFenetre();
} else if (etaitEnAir && aVitesse) {
// Ticks candidats couverts par ce paquet : n exactement à l'heure ; n-1 ou n en retard ; 1 si 0.
int kMin = n <= 1 ? 1 : n - 1;
@@ -51,9 +70,11 @@ public final class VolVertical {
boolean ecart = true;
double v = derniereVitesse;
double somme = 0;
double sommeMax = -Double.MAX_VALUE; // la prévision la plus haute parmi les ticks candidats
for (int k = 1; k <= kMax; k++) {
v = (v - GRAVITE) * TRAINEE;
somme += v;
if (k >= kMin) sommeMax = Math.max(sommeMax, somme);
if (k >= kMin && Math.abs(dy - somme) <= TOLERANCE * k) {
ecart = false;
vitesseFin = n <= 1 ? dy : v;
@@ -65,6 +86,9 @@ public final class VolVertical {
if (anormauxConsecutifs > TICKS_ANORMAUX) {
points = 1.0 + Math.min(3.0, (anormauxConsecutifs - TICKS_ANORMAUX) / 10.0);
}
if (fenetreGlissante) {
points = Math.max(points, fenetreGlissante(ecart, dy, sommeMax, Math.max(1, n)));
}
}
derniereVitesse = vitesseFin;
@@ -73,10 +97,45 @@ public final class VolVertical {
return points;
}
/**
* C10 (16/10) : le compteur de ticks anormaux consécutifs redescend d'un cran à chaque tick normal ; un saut en
* l'air tous les 10 ticks, ou l'alternance d'un tick plané et d'un tick de gravité, ne l'atteignaient jamais.
* En plus : ticks anormaux comptés sur une fenêtre glissante, et tout gain d'altitude franc en l'air (sans sol,
* hors exemptions : recul, téléportation, milieux spéciaux) compté comme un saut en l'air ; le deuxième à moins
* de {@link #SAUTS_FENETRE_TICKS} ticks en l'air du précédent est une infraction.
*/
private double fenetreGlissante(boolean ecart, double dy, double prevision, int ticks) {
ticksEnAir += ticks;
if (fenetre[fenetreIndex]) fenetreAnormaux--;
fenetre[fenetreIndex] = ecart;
if (ecart) fenetreAnormaux++;
fenetreIndex = (fenetreIndex + 1) % FENETRE_TICKS;
double points = 0;
if (fenetreAnormaux > FENETRE_ANORMAUX_MAX) {
points = 1.0 + Math.min(3.0, (fenetreAnormaux - FENETRE_ANORMAUX_MAX) / 4.0);
}
if (ecart && dy > 0 && dy - prevision >= SAUT_EN_L_AIR_MIN) {
if (dernierSautEnAir != Integer.MIN_VALUE && ticksEnAir - dernierSautEnAir <= SAUTS_FENETRE_TICKS) {
points = Math.max(points, 2.0);
}
dernierSautEnAir = ticksEnAir;
}
return points;
}
private void viderFenetre() {
java.util.Arrays.fill(fenetre, false);
fenetreIndex = 0;
fenetreAnormaux = 0;
ticksEnAir = 0;
dernierSautEnAir = Integer.MIN_VALUE;
}
public void vider() {
derniereVitesse = 0;
aVitesse = false;
etaitEnAir = false;
anormauxConsecutifs = 0;
viderFenetre();
}
}
+22 -7
Voir le fichier
@@ -154,15 +154,22 @@ class AutotestContournementsTest {
v.addAll(moteur.regardPorteeHitbox(joueur, 50, proche, vers(proche, 0, 1.0, 0)));
assertTrue(points(v, Controle.PORTEE) > 0, "corrigé : s'avancer de 0,8 bloc au paquet suivant n'efface plus la portée");
// Angle killaura : regard à 180° au coup, sur la cible au paquet suivant.
// Angle killaura : regard à 180° au coup, sur la cible au paquet suivant. Un coup isolé n'est pas compté (un
// demi-tour honnête existe : Garde1016Test.angleKillauraRegardEnRetardPasDeFauxPositif) ; une série, si.
// [À VÉRIFIER] Théo : le témoin d'origine portait sur un seul coup.
cfg.mode(Controle.PORTEE, Mode.OFF);
cfg.mode(Controle.HITBOX, Mode.OFF);
moteur = new Moteur(cfg);
double[] oeil = {0, 1.62, -2.5};
List<Verdict> a = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil, new double[] {0, 0, -1},
b, 3.0, 0, false, true));
a.addAll(moteur.regardPorteeHitbox(joueur, 50, oeil, vers(oeil, 0, 1.0, 0)));
assertTrue(points(a, Controle.KILLAURA_ANGLE) > 0, "corrigé : rotation silencieuse de 180° non effacée");
double serie = 0;
for (int k = 0; k < 10; k++) {
List<Verdict> a = new ArrayList<>(moteur.coupDiffere(joueur, k * 600L, EtatJoueur.normal(), oeil,
new double[] {0, 0, -1}, b, 3.0, 0, false, true));
a.addAll(moteur.regardPorteeHitbox(joueur, k * 600L + 50, oeil, vers(oeil, 0, 1.0, 0)));
if (k == 0) assertEquals(0, points(a, Controle.KILLAURA_ANGLE), 1e-9, "un demi-tour isolé : rien");
serie += points(a, Controle.KILLAURA_ANGLE);
}
assertTrue(serie > 0, "corrigé : rotations silencieuses de 180° répétées vues");
}
/**
@@ -222,8 +229,11 @@ class AutotestContournementsTest {
for (int k = 0; k < 10; k++) {
double x = 10 * k;
double[] oeil = {x - 1.5, 1.62, -2.5};
// Client « hitbox » : touche 3,3 blocs DERRIÈRE le centre de la cible (là où elle était il y a ~12 ticks).
double[] regard = vers(oeil, x - 3.6, 1.2, 0);
// Client « hitbox » : touche loin DERRIÈRE le centre de la cible (là où elle était il y a ~15 ticks).
// 16/10 (correctif) : 4,2 au lieu de 3,6. Avec la marge de 50 ms sur le plancher (30 + 50 ms : 9 ticks
// au lieu de 8), le point à 3,6 tombait au bord de la fenêtre (manque 0,135 < 0,15) ; à 4,2 il reste
// caché par une fenêtre de 16 ticks (450 ms) et vu avec 8 ou 9. [À VÉRIFIER] Théo : témoin modifié.
double[] regard = vers(oeil, x - 4.2, 1.2, 0);
total += points(coup(k * 600L, etat, oeil, regard, oeil, regard, x, vues(x, fenetre)),
Controle.COUPS_HORS_BOITE);
}
@@ -235,7 +245,12 @@ class AutotestContournementsTest {
assertEquals(8, PorteeHitbox.ticksFenetre(30, cfg));
assertEquals(16, PorteeHitbox.ticksFenetre(450, cfg));
assertEquals(17, PorteeHitbox.ticksFenetre(500, cfg));
assertTrue(serieDerriereLaCible(450, 450) == 0, "témoin : fenêtre de 16 ticks (450 ms durables), cachée");
assertTrue(serieDerriereLaCible(30, 30) > 0, "témoin : à 30 ms, la série est vue");
moteur = new Moteur(cfg);
for (long t = 0; t < 60_000; t += 1000) moteur.pingFenetre(joueur, t, 30);
assertEquals(9, PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 60_000, 450), cfg),
"corrigé : 30 ms puis 450 annoncés : fenêtre de 9 ticks (plancher 30 + marge 50), pas 16");
assertTrue(serieDerriereLaCible(30, 450) > 0,
"corrigé : 30 ms pendant une minute puis 450 ms annoncés en combat : toujours vu");
// Joueur honnête qui a 450 ms depuis le début : fenêtre complète.
+2 -1
Voir le fichier
@@ -175,7 +175,8 @@ class Garde92Test {
EtatJoueur.builder().enVehicule(true).build(),
EtatJoueur.builder().elytres(true).build(),
EtatJoueur.builder().riptide(true).build(),
EtatJoueur.builder().pingMs(cfg.seriePingMaxMs + 1).build(),
// Revue 1 (16/10) : un ping > seriePingMaxMs n'exempte plus (ping falsifiable) ; retiré de la liste,
// voir AutotestContournementsTest.CORRIGE_revue1_… [À VÉRIFIER] Théo.
EtatJoueur.builder().ticksDepuisTeleport(5).build(),
EtatJoueur.builder().ticksDepuisGel(5).build());
for (EtatJoueur etat : etats) {