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 à :
1 Parent
080415c646
révision
4776895371
12 fichiers modifiés
+340
-31
Aucun fichier ne correspond à votre recherche
@@ -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());
|
||||
|
||||
@@ -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};
|
||||
}
|
||||
}
|
||||
@@ -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. */
|
||||
|
||||
@@ -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()));
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
|
||||
@@ -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) {
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur