Comparer les révisions
9
Révisions
| Auteur | SHA1 | Date | ||
|---|---|---|---|---|
| ||||
|
|
9c2814a30e | |||
|
|
e33225c0d0 | |||
|
|
b34a3b3aeb | |||
|
|
4be81eed65 | |||
|
|
4776895371 | |||
|
|
080415c646 | |||
|
|
d9530d0661 | |||
|
|
9335654541 | |||
|
|
56a98f3a5c | |||
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());
|
||||
@@ -547,6 +571,7 @@ public final class Garde {
|
||||
/** Début du traitement d'un paquet de mouvement : contrôle du débit. */
|
||||
public static void avantMouvement(ServerPlayer p) {
|
||||
if (!surThreadServeur(p)) return; // F01 : jamais depuis le thread réseau (le mixin l'évite déjà)
|
||||
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 : expulsion en cours, plus rien à évaluer
|
||||
if (estExempteManuellement(p.getUUID())) return;
|
||||
EtatJoueur etat = etat(p, false);
|
||||
List<Verdict> v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat);
|
||||
@@ -557,6 +582,7 @@ public final class Garde {
|
||||
/** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */
|
||||
public static void apresMouvement(ServerPlayer p) {
|
||||
if (!surThreadServeur(p)) return;
|
||||
if (MOTEUR.estExpulse(p.getUUID())) return; // C4 / C6 : ni évaluation ni état recréé après l'expulsion
|
||||
int tick = p.server.getTickCount();
|
||||
Marques m = marques(p.getUUID());
|
||||
boolean solServeur = auSolServeur(p, m);
|
||||
@@ -601,7 +627,9 @@ public final class Garde {
|
||||
|
||||
// En véhicule, la position du joueur est celle du véhicule, non contrôlée ici : elle n'est mémorisée
|
||||
// qu'après un paquet de véhicule sans verdict (apresVehicule), sinon un setback y ramènerait.
|
||||
if (m.dernierVerdictTick != tick && !vehiculeControle(p)) {
|
||||
// C3 (16/10) : seulement au sol vu par le serveur (ou eau, échelle…), jamais une position en l'air.
|
||||
if (m.dernierVerdictTick != tick && !vehiculeControle(p)
|
||||
&& MOTEUR.positionDeRetourAdmise(solServeur, em != null && em.milieuSpecial())) {
|
||||
MOTEUR.suivi(p.getUUID()).memoriserPosition(p.getX(), p.getY(), p.getZ(), p.getYRot(), p.getXRot(),
|
||||
p.level().dimension().location().toString());
|
||||
}
|
||||
@@ -870,6 +898,8 @@ public final class Garde {
|
||||
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
|
||||
String raison = verdicts.isEmpty() ? "anti-triche" : verdicts.get(0).controle().id();
|
||||
if (s == Sanction.EXPULSION) {
|
||||
// C4 (16/10) : une seule expulsion par incident (avant : 344 disconnect en 18 s). Jamais de bannissement.
|
||||
if (!MOTEUR.expulser(p.getUUID(), p.server.getTickCount() * 50L)) return;
|
||||
ecrireJournal(p.getGameProfile().getName() + " EXPULSE (" + raison + ")");
|
||||
p.connection.disconnect(Component.literal("Expulsé par l'anti-triche (" + raison + ")."));
|
||||
} else if (s == Sanction.SETBACK) {
|
||||
@@ -878,6 +908,8 @@ public final class Garde {
|
||||
if (sv.aPositionValide() && sv.dimension().equals(dim)) {
|
||||
annoncerTeleport(p, GraceTeleport.Origine.SETBACK);
|
||||
p.connection.teleport(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch());
|
||||
// C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol.
|
||||
MOTEUR.apresSetback(p.getUUID(), p.server.getTickCount() * 50L);
|
||||
ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -57,6 +57,10 @@ public final class GardeEvents {
|
||||
@SubscribeEvent
|
||||
public static void onAttaque(AttackEntityEvent event) {
|
||||
if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return;
|
||||
if (Garde.moteur().estExpulse(p.getUUID())) { // C4 : expulsion en cours
|
||||
event.setCanceled(true);
|
||||
return;
|
||||
}
|
||||
if (Garde.estExempteManuellement(p.getUUID())) return;
|
||||
|
||||
Entity cible = event.getTarget();
|
||||
@@ -135,7 +139,10 @@ public final class GardeEvents {
|
||||
|
||||
@SubscribeEvent
|
||||
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
|
||||
if (event.getEntity() instanceof ServerPlayer p) Garde.noterTeleport(p);
|
||||
if (event.getEntity() instanceof ServerPlayer p) {
|
||||
Garde.moteur().oublierExpulsion(p.getUUID()); // C4 : la marque d'expulsion vaut jusqu'à la reconnexion
|
||||
Garde.noterTeleport(p);
|
||||
}
|
||||
}
|
||||
|
||||
@SubscribeEvent
|
||||
|
||||
@@ -49,6 +49,10 @@ public final class GardeSpec {
|
||||
|
||||
private static final ModConfigSpec.IntValue TICKS_AFFICHAGE;
|
||||
private static final ModConfigSpec.IntValue SERIE_PING_MAX;
|
||||
private static final ModConfigSpec.IntValue SERIE_PING_MARGE;
|
||||
private static final ModConfigSpec.IntValue TIMER_SOLDE_MAX;
|
||||
private static final ModConfigSpec.BooleanValue VOL_FENETRE_GLISSANTE;
|
||||
private static final ModConfigSpec.BooleanValue VITESSE_MOYENNE;
|
||||
private static final ModConfigSpec.DoubleValue SERIE_MANQUE;
|
||||
private static final ModConfigSpec.DoubleValue SERIE_PORTEE;
|
||||
private static final ModConfigSpec.IntValue SERIE_COUPS;
|
||||
@@ -125,8 +129,10 @@ public final class GardeSpec {
|
||||
"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é.")
|
||||
SERIE_PING_MAX = b.comment("Ping (ms) pris en compte au plus dans la fenêtre (au-delà, le coup est mesuré avec cette fenêtre).")
|
||||
.defineInRange("seriePingMaxMs", 500, 100, 500);
|
||||
SERIE_PING_MARGE = b.comment("Fenêtre selon le ping le plus bas des 2 dernières minutes + cette marge (ms), pas le ping du moment.")
|
||||
.defineInRange("seriePingMargeMs", 50, 0, 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).")
|
||||
@@ -140,12 +146,21 @@ public final class GardeSpec {
|
||||
b.push("timer");
|
||||
PAQUETS_PAR_SECONDE = b.defineInRange("paquetsParSecondeMax", 22, 20, 200);
|
||||
TIMER_SECONDES = b.defineInRange("secondesSoutenues", 3, 1, 30);
|
||||
TIMER_SOLDE_MAX = b.comment("C15 : solde de paquets (reçus - ticks écoulés) au-delà duquel le timer compte (timer 1,05-1,10).",
|
||||
"0 = désactivé (défaut). Essai conseillé : 20, en OBSERVE.")
|
||||
.defineInRange("timerSoldeMax", 0, 0, 1000);
|
||||
b.pop();
|
||||
|
||||
b.push("mouvement");
|
||||
EXCES_VITESSE = b.comment("Total d'excès de vitesse horizontale (blocs) sur 20 ticks avant une infraction.",
|
||||
"Valeurs de départ généreuses, à resserrer avec les traces réelles.")
|
||||
.defineInRange("excesVitesseBlocs", 1.5, 0.1, 100.0);
|
||||
VOL_FENETRE_GLISSANTE = b.comment("C10 : vol, ticks anormaux sur une fenêtre glissante et sauts en l'air répétés.",
|
||||
"Désactivé par défaut : à essayer en OBSERVE (vol est en ENFORCE en production).")
|
||||
.define("volFenetreGlissante", false);
|
||||
VITESSE_MOYENNE = b.comment("C15 : vitesse moyenne sur 40 paquets comparée à la moyenne vanilla (course, sprint-saut).",
|
||||
"Désactivé par défaut : à essayer en OBSERVE (fausse alerte possible sous un plafond bas, C16).")
|
||||
.define("vitesseMoyenne", false);
|
||||
b.pop();
|
||||
|
||||
b.push("exemptions");
|
||||
@@ -248,6 +263,10 @@ public final class GardeSpec {
|
||||
c.vitesseCibleMaxMesure = VITESSE_CIBLE_MAX.get();
|
||||
c.ticksAffichageCible = TICKS_AFFICHAGE.get();
|
||||
c.seriePingMaxMs = SERIE_PING_MAX.get();
|
||||
c.seriePingMargeMs = SERIE_PING_MARGE.get();
|
||||
c.timerSoldeMax = TIMER_SOLDE_MAX.get();
|
||||
c.volFenetreGlissante = VOL_FENETRE_GLISSANTE.get();
|
||||
c.vitesseMoyenne = VITESSE_MOYENNE.get();
|
||||
c.serieManqueBlocs = SERIE_MANQUE.get();
|
||||
c.seriePorteeMargeBlocs = SERIE_PORTEE.get();
|
||||
c.serieCoups = SERIE_COUPS.get();
|
||||
|
||||
@@ -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};
|
||||
}
|
||||
}
|
||||
@@ -17,6 +17,14 @@ public final class GardeConfig {
|
||||
public double seuilExpulsion = 20.0;
|
||||
/** Sanction la plus forte autorisée (T4 : setback puis expulsion, jamais de bannissement). */
|
||||
public Sanction sanctionMax = Sanction.EXPULSION;
|
||||
/**
|
||||
* C5 (16/10) : un retour en arrière remet le VL du contrôle à zéro ; l'expulsion pour un contrôle de mouvement
|
||||
* vient quand ce nombre de setbacks a déjà eu lieu dans {@link #fenetreSetbacksMs}.
|
||||
*/
|
||||
public int setbacksAvantExpulsion = 4;
|
||||
public long fenetreSetbacksMs = 60_000;
|
||||
/** C1 (16/10) : ticks de grâce du contrôle vol après la fin du plané en élytres (fin à l'atterrissage). */
|
||||
public int graceFinElytresTicks = 50;
|
||||
|
||||
// --- Killaura ---
|
||||
/** Angle maximal entre le regard et la silhouette de la cible, en degrés. */
|
||||
@@ -64,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;
|
||||
@@ -78,6 +86,19 @@ public final class GardeConfig {
|
||||
public long serieFenetreMs = 30000;
|
||||
/** Points par coup hors boîte dans une série suspecte. */
|
||||
public double seriePoints = 2.0;
|
||||
/**
|
||||
* 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 = 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. */
|
||||
public boolean volFenetreGlissante = false;
|
||||
/** C15 : vitesse moyenne sur 2 s comparée à la moyenne vanilla (course, sprint-saut). */
|
||||
public boolean vitesseMoyenne = false;
|
||||
/** C15 : solde de paquets de mouvement (reçus - ticks écoulés) au-delà duquel le timer compte ; 0 = désactivé. */
|
||||
public int timerSoldeMax = 0;
|
||||
|
||||
// --- Exemptions ---
|
||||
public int graceTeleportTicks = 40;
|
||||
|
||||
@@ -21,6 +21,8 @@ public final class Moteur {
|
||||
|
||||
private final GardeConfig cfg;
|
||||
private final Map<UUID, Suivi> suivis = new HashMap<>();
|
||||
/** C4 : joueurs déjà expulsés (jusqu'à leur reconnexion). */
|
||||
private final java.util.Set<UUID> expulses = new java.util.HashSet<>();
|
||||
|
||||
public Moteur(GardeConfig cfg) {
|
||||
this.cfg = cfg;
|
||||
@@ -54,6 +56,7 @@ public final class Moteur {
|
||||
*/
|
||||
public List<Verdict> attaque(UUID joueur, long nowMs, EtatJoueur etat, double excedentDegres,
|
||||
int idCible, boolean cibleVisible) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.COMBAT);
|
||||
if (ex.exempt()) return List.of();
|
||||
|
||||
@@ -97,6 +100,7 @@ public final class Moteur {
|
||||
*/
|
||||
public List<Verdict> porteeHitbox(UUID joueur, long nowMs, EtatJoueur etat, double distance, double manque,
|
||||
double porteeJoueur, double vitesseCible) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
boolean portee = cfg.mode(Controle.PORTEE) != Mode.OFF;
|
||||
boolean hitbox = cfg.mode(Controle.HITBOX) != Mode.OFF;
|
||||
if (!portee && !hitbox) return List.of();
|
||||
@@ -165,6 +169,7 @@ public final class Moteur {
|
||||
double[] boite, double porteeJoueur, double vitesseCible,
|
||||
boolean porteeHitbox, boolean angle, double[] oeilPrecedent,
|
||||
double[][] boitesVues) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
List<Verdict> verdicts = terminerCoup(joueur);
|
||||
boolean serie = porteeHitbox && boitesVues != null && boitesVues.length > 0
|
||||
&& cfg.mode(Controle.COUPS_HORS_BOITE) != Mode.OFF;
|
||||
@@ -180,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;
|
||||
}
|
||||
@@ -217,13 +221,26 @@ 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;
|
||||
}
|
||||
|
||||
/**
|
||||
* Revue 4 (16/10) : ping à utiliser pour la fenêtre d'historique de coups-hors-boite (voir
|
||||
* {@link PorteeHitbox#ticksFenetre}). Note aussi le ping déclaré.
|
||||
*/
|
||||
public int pingFenetre(UUID joueur, long nowMs, int 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. */
|
||||
public List<Verdict> regardPorteeHitbox(UUID joueur, long nowMs, double[] oeil, double[] regard) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
Suivi s = suivis.get(joueur);
|
||||
if (s == null || s.coupDiffere == null) return List.of();
|
||||
if (s.coupDiffere.encoreValable(nowMs)) s.coupDiffere.affiner(oeil, regard);
|
||||
@@ -244,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) {
|
||||
@@ -270,6 +293,7 @@ public final class Moteur {
|
||||
*/
|
||||
public List<Verdict> regard(UUID joueur, long nowMs, java.util.function.Supplier<EtatJoueur> etat,
|
||||
float yaw, float pitch) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
if (cfg.mode(Controle.ROTATION) == Mode.OFF) return List.of();
|
||||
Suivi s = suivi(joueur);
|
||||
double pts = s.rotation.regard(nowMs / 50, yaw, pitch);
|
||||
@@ -285,6 +309,7 @@ public final class Moteur {
|
||||
|
||||
/** Un paquet de mouvement vient d'arriver (temps réel en ms, pour mesurer le débit). */
|
||||
public List<Verdict> paquetMouvement(UUID joueur, long nowMs, EtatJoueur etat) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
if (cfg.mode(Controle.TIMER) == Mode.OFF) return List.of();
|
||||
Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER);
|
||||
if (ex.exempt()) {
|
||||
@@ -304,6 +329,7 @@ public final class Moteur {
|
||||
* Les exemptions de mouvement (riptide, élytres, contraption, téléportation, recul…) coupent tout.
|
||||
*/
|
||||
public List<Verdict> mouvement(UUID joueur, long nowMs, EtatJoueur etat, EtatMouvement m) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
boolean noFall = cfg.mode(Controle.NO_FALL) != Mode.OFF;
|
||||
boolean vitesse = cfg.mode(Controle.VITESSE) != Mode.OFF;
|
||||
boolean vol = cfg.mode(Controle.VOL) != Mode.OFF;
|
||||
@@ -315,6 +341,10 @@ public final class Moteur {
|
||||
// 15/10 : l'élan réel de la période exemptée est gardé (élytres arrêtées en plein vol, recul…).
|
||||
s.vitesse.exempter(m, ex.facteur(), sortieDEtat(ex.raisons()));
|
||||
s.vol.vider();
|
||||
// C1 (16/10, incident Rednixxu) : le drapeau élytres tombe côté serveur alors que le client plane encore.
|
||||
if (ex.raisons().contains("elytres")) {
|
||||
s.graceElytresJusquaMs = nowMs + cfg.graceFinElytresTicks * 50L;
|
||||
}
|
||||
return List.of();
|
||||
}
|
||||
List<Verdict> verdicts = new ArrayList<>(3);
|
||||
@@ -323,12 +353,22 @@ 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(),
|
||||
s.vitesse.dernierPermis() * Math.max(1, m.ticks()), m.ticks(), VitesseHorizontale.vitesseMax(m)));
|
||||
}
|
||||
if (vol) {
|
||||
boolean graceElytres = false;
|
||||
if (m.auSolServeur()) {
|
||||
s.graceElytresJusquaMs = Long.MIN_VALUE; // atterrissage : fin de la grâce de fin d'élytres
|
||||
} else if (nowMs <= s.graceElytresJusquaMs) {
|
||||
graceElytres = true;
|
||||
}
|
||||
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()));
|
||||
}
|
||||
@@ -350,6 +390,7 @@ public final class Moteur {
|
||||
* Un mouvement de véhicule piloté par le joueur, accepté par le serveur (F20) : vitesse et vol du véhicule.
|
||||
*/
|
||||
public List<Verdict> vehicule(UUID joueur, long nowMs, EtatJoueur etat, EtatVehicule m) {
|
||||
if (expulses.contains(joueur)) return new ArrayList<>(0); // C4
|
||||
boolean vitesse = cfg.mode(Controle.VEHICULE_VITESSE) != Mode.OFF;
|
||||
boolean vol = cfg.mode(Controle.VEHICULE_VOL) != Mode.OFF;
|
||||
if (!vitesse && !vol) return List.of();
|
||||
@@ -395,6 +436,49 @@ public final class Moteur {
|
||||
return NoFall.auSolEffectif(auSolClient, auSolServeur, ex.exempt(), cfg.mode(Controle.NO_FALL));
|
||||
}
|
||||
|
||||
// --- Setback, expulsion, position de retour (16/10, incident VOL) ----------------------------------------
|
||||
|
||||
/**
|
||||
* C2 (16/10) : un retour en arrière vient d'être appliqué. Le contrôle vol et la vitesse repartent de zéro (le
|
||||
* paquet suivant sert de référence) et leurs VL sont remis à zéro ; le setback est compté pour l'escalade (C5).
|
||||
*/
|
||||
public void apresSetback(UUID joueur, long nowMs) {
|
||||
Suivi s = suivi(joueur);
|
||||
s.vol.vider();
|
||||
s.vitesse.vider();
|
||||
s.graceElytresJusquaMs = Long.MIN_VALUE;
|
||||
s.vl.remettreAZero(Controle.VOL);
|
||||
s.vl.remettreAZero(Controle.VITESSE);
|
||||
s.noterSetback(nowMs);
|
||||
}
|
||||
|
||||
/**
|
||||
* C4 (16/10) : expulsion à usage unique. Vrai la première fois seulement ; ensuite le joueur n'est plus évalué
|
||||
* jusqu'à sa reconnexion ({@link #oublierExpulsion}). La marque survit à {@link #retirer} (C6).
|
||||
*/
|
||||
public boolean expulser(UUID joueur, long nowMs) {
|
||||
return expulses.add(joueur);
|
||||
}
|
||||
|
||||
public boolean estExpulse(UUID joueur) {
|
||||
return expulses.contains(joueur);
|
||||
}
|
||||
|
||||
/** Reconnexion du joueur : il repart d'un état neuf. */
|
||||
public void oublierExpulsion(UUID joueur) {
|
||||
expulses.remove(joueur);
|
||||
suivis.remove(joueur);
|
||||
}
|
||||
|
||||
/**
|
||||
* C3 (16/10) : la position d'un paquet sans verdict ne sert de retour en arrière que si le joueur est au sol vu
|
||||
* par le serveur (ou dans un milieu où la gravité vanilla ne s'applique pas : eau, échelle…). Avant, toute
|
||||
* position était gardée, y compris pendant les 10 ticks anormaux tolérés : retour en l'air.
|
||||
*/
|
||||
public boolean positionDeRetourAdmise(boolean auSolServeur, boolean milieuSpecial) {
|
||||
return auSolServeur || milieuSpecial;
|
||||
}
|
||||
|
||||
// --- Interne ----------------------------------------------------------------------------------------
|
||||
|
||||
private void ajouter(List<Verdict> sortie, Suivi s, Controle c, double points, long nowMs,
|
||||
@@ -403,6 +487,11 @@ public final class Moteur {
|
||||
Mode mode = cfg.mode(c);
|
||||
double vl = s.vl.ajouter(c, points, nowMs);
|
||||
Sanction palier = Paliers.palier(vl, cfg);
|
||||
// C5 (16/10) : après un setback, le VL repart de zéro ; l'expulsion vient après plusieurs setbacks récents.
|
||||
if (palier == Sanction.SETBACK && cfg.setbacksAvantExpulsion > 0
|
||||
&& s.setbacksRecents(nowMs, cfg.fenetreSetbacksMs) >= cfg.setbacksAvantExpulsion) {
|
||||
palier = Sanction.min(Sanction.EXPULSION, cfg.sanctionMax);
|
||||
}
|
||||
Sanction applicable = Paliers.applicable(palier, mode);
|
||||
boolean notifier = applicable.ordinal() >= Sanction.ALERTE.ordinal()
|
||||
&& s.autoriserAlerte(c, nowMs, DELAI_ALERTE_MS);
|
||||
|
||||
@@ -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,11 +16,34 @@ 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;
|
||||
/** Jusqu'à quand (ms) les coups sont annulés après une sanction portée / hitbox en ENFORCE. */
|
||||
long coupsBloquesJusqua = Long.MIN_VALUE;
|
||||
/** C1 (16/10) : fin de la grâce du contrôle vol après le plané en élytres (ms). */
|
||||
long graceElytresJusquaMs = Long.MIN_VALUE;
|
||||
/** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */
|
||||
private final java.util.ArrayDeque<Long> setbacks = new java.util.ArrayDeque<>();
|
||||
|
||||
void noterSetback(long nowMs) {
|
||||
setbacks.addLast(nowMs);
|
||||
while (setbacks.size() > 32) setbacks.removeFirst();
|
||||
}
|
||||
|
||||
/** Nombre de setbacks dans la fenêtre {@code fenetreMs} qui précède {@code nowMs}. */
|
||||
int setbacksRecents(long nowMs, long fenetreMs) {
|
||||
int n = 0;
|
||||
for (long t : setbacks) if (nowMs - t <= fenetreMs) n++;
|
||||
return n;
|
||||
}
|
||||
|
||||
// Dernière position jugée valide (retour en arrière).
|
||||
private boolean positionValide;
|
||||
|
||||
@@ -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();
|
||||
}
|
||||
}
|
||||
@@ -42,6 +42,11 @@ public final class VlCompteur {
|
||||
etats.clear();
|
||||
}
|
||||
|
||||
/** C2 (16/10) : remet à zéro un seul contrôle (après un setback). */
|
||||
public void remettreAZero(Controle c) {
|
||||
etats.remove(c);
|
||||
}
|
||||
|
||||
private double decayed(Etat e, long nowMs) {
|
||||
if (nowMs <= e.dernierMs) return e.valeur;
|
||||
double perdu = (nowMs - e.dernierMs) / 1000.0 * decroissanceParSeconde;
|
||||
|
||||
@@ -19,6 +19,33 @@ public final class VolVertical {
|
||||
private boolean etaitEnAir;
|
||||
private int anormauxConsecutifs;
|
||||
|
||||
/**
|
||||
* Rafales réseau (16/10) : ticks serveur écoulés moins ticks client couverts par les paquets déjà vus. Un paquet
|
||||
* d'un tick client reçu après 3 ticks serveur laisse 2 ticks « dus », couverts ensuite par les paquets à 0 tick de
|
||||
* la même rafale. Borné à {@link #AVANCE_MAX} : au-delà, on revient à la règle stricte (n-1 ou n ticks), donc
|
||||
* un client qui ralentit durablement sa chute (un tick de gravité toutes les 3 ticks) reste vu.
|
||||
*/
|
||||
public static final int AVANCE_MAX = 4;
|
||||
private int avance;
|
||||
|
||||
// --- 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;
|
||||
|
||||
@@ -35,6 +62,7 @@ public final class VolVertical {
|
||||
int n = e.ticks();
|
||||
if (n > TICKS_MAX || n < 0) {
|
||||
aVitesse = false;
|
||||
avance = 0;
|
||||
return 0;
|
||||
}
|
||||
boolean enAir = !e.auSolServeur();
|
||||
@@ -44,27 +72,38 @@ public final class VolVertical {
|
||||
|
||||
if (exempt || e.milieuSpecial() || !enAir) {
|
||||
anormauxConsecutifs = 0;
|
||||
avance = 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;
|
||||
// Rafales : jusqu'à AVANCE_MAX ticks dus peuvent rester en attente ; la règle d'avant reste toujours admise.
|
||||
int kMin = Math.max(1, Math.min(n <= 1 ? 1 : n - 1, n + avance - AVANCE_MAX));
|
||||
int kMax = Math.max(1, n);
|
||||
int kRetenu = kMax;
|
||||
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;
|
||||
kRetenu = k;
|
||||
}
|
||||
}
|
||||
avance = Math.max(0, Math.min(AVANCE_MAX, avance + n - kRetenu));
|
||||
// Le plané (|dy| quasi nul en l'air) est anormal aussi : la prévision serait au moins -0,08 par tick.
|
||||
if (ecart) anormauxConsecutifs++;
|
||||
else anormauxConsecutifs = Math.max(0, anormauxConsecutifs - 1);
|
||||
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 +112,46 @@ 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;
|
||||
avance = 0;
|
||||
viderFenetre();
|
||||
}
|
||||
}
|
||||
@@ -16,8 +16,8 @@ import org.junit.jupiter.api.Test;
|
||||
/**
|
||||
* Autotests du 16/10/2026, nuit : contournement n°3 de la revue de sécurité (table SUIVIES pleine).
|
||||
*
|
||||
* Garde.boitesVues n'ajoute une cible non joueur à la table que si elle compte moins de SUIVIES_MAX entrées ; sinon
|
||||
* elle renvoie null (pas de mesure) et ne la suivra jamais tant que la table reste pleine. La table est commune à
|
||||
* Corrigé le 16/10 (branche fix/hitbox-c10-c13-c15) : quand la table est pleine, la cible non joueur suivie dont le
|
||||
* dernier coup est le plus ancien est évincée au profit de la nouvelle (avant : la nouvelle n'était jamais suivie). La table est commune à
|
||||
* tout le serveur, les joueurs connectés y comptent aussi (sans plafond), une entrée vit 10 s après le dernier coup.
|
||||
*
|
||||
* Le test remplit la table par réflexion avec des identifiants négatifs (jamais attribués) et frappe une entité
|
||||
@@ -28,7 +28,7 @@ class AutotestSuiviesTest {
|
||||
|
||||
@SuppressWarnings("unchecked")
|
||||
@Test
|
||||
void FAILLE_revue3_tablePleineLesNouvellesCiblesNeSontJamaisSuivies() throws Exception {
|
||||
void CORRIGE_revue3_tablePleineLaNouvelleCibleEvinceLaPlusAncienne() throws Exception {
|
||||
Field fTable = Garde.class.getDeclaredField("SUIVIES");
|
||||
fTable.setAccessible(true);
|
||||
Map<Integer, Object> table = (Map<Integer, Object>) fTable.get(null);
|
||||
@@ -52,11 +52,9 @@ class AutotestSuiviesTest {
|
||||
|
||||
table.clear();
|
||||
for (int i = 0; i < max; i++) table.put(-1 - i, null);
|
||||
for (int k = 0; k < 5; k++) {
|
||||
assertNull(Garde.boitesVues(cible, null, 1000 + 20 * k), "coup " + k + " non mesuré");
|
||||
}
|
||||
assertFalse(table.containsKey(cible.getId()), "prouvé : table pleine, la cible n'est jamais suivie");
|
||||
assertEquals(max, table.size(), "aucune éviction");
|
||||
assertNull(Garde.boitesVues(cible, null, 1000), "premier coup : historique incomplet");
|
||||
assertTrue(table.containsKey(cible.getId()), "corrigé : table pleine, la cible est quand même suivie");
|
||||
assertEquals(max, table.size(), "une entrée évincée, la table ne grandit pas");
|
||||
} finally {
|
||||
table.clear();
|
||||
}
|
||||
|
||||
@@ -336,12 +336,14 @@ class AutotestCasLimitesTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_lagRafalesDeTroisPaquetsPendantUneLongueChute() {
|
||||
void CORRIGE_lagRafalesDeTroisPaquetsPendantUneLongueChute() {
|
||||
// Inversé le 16/10 (fix/rafales-reseau) : était FAUX_POSITIF_ (88,9 points).
|
||||
// Ancien commentaire :
|
||||
// Un paquet d'UN tick client arrivé après 3 ticks serveur n'est comparé qu'à 2 ou 3 ticks de gravité, et la
|
||||
// vitesse retenue est alors dy / 3 : le paquet suivant est faux aussi. Motif 3, 0, 0 : +1 anomalie par rafale,
|
||||
// premier point après ~31 paquets (1,5 s de chute, ~12 blocs). Simulé, à confirmer avec une trace réelle.
|
||||
double total = chuteAvecGigue(new int[] {3, 0, 0});
|
||||
assertTrue(total > 0);
|
||||
assertEquals(0, total, 1e-9);
|
||||
Mesures.noter("Lag 3,0,0 : " + total + " points de vol sur une chute de 80 paquets");
|
||||
}
|
||||
|
||||
|
||||
@@ -13,8 +13,9 @@ import org.junit.jupiter.api.Test;
|
||||
* Autotests du 16/10/2026, nuit : contournements signalés par la revue de sécurité automatique des commits 7a5a1c9 /
|
||||
* 937d43d (contrôle coups-hors-boite) et constats C13, C15 de l'autocritique.
|
||||
*
|
||||
* Un test {@code FAILLE_…} passe tant que le contournement marche ; il échouera quand il sera corrigé (inverser
|
||||
* alors l'assertion). Chaque faille a un test « témoin » qui montre que, sans le contournement, la triche est vue.
|
||||
* Corrigés le 16/10 (branche fix/hitbox-c10-c13-c15) : les anciens tests {@code FAILLE_…} ont été inversés et
|
||||
* renommés {@code CORRIGE_…}. Chaque faille garde son test « témoin » ; les détections C15 sont des options
|
||||
* désactivées par défaut, activées ici, avec un témoin honnête qui ne doit rien donner.
|
||||
* Le contournement n°3 (table SUIVIES pleine) dépend de Minecraft : voir {@code com.gastinelgarde.AutotestSuiviesTest}.
|
||||
*/
|
||||
class AutotestContournementsTest {
|
||||
@@ -78,16 +79,16 @@ class AutotestContournementsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_revue1_pingDeclareAuDessusDe500msExempteTotalementLesCoups() {
|
||||
void CORRIGE_revue1_pingDeclareAuDessusDe500msNExemptePlusLesCoups() {
|
||||
assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs) > 0, "témoin : à 500 ms, la série est vue");
|
||||
assertEquals(0, serieHitboxAvecPing(cfg.seriePingMaxMs + 1), 1e-9,
|
||||
"prouvé : à 501 ms (ping falsifiable, F07), aucun coup n'est mesuré");
|
||||
assertTrue(serieHitboxAvecPing(cfg.seriePingMaxMs + 1) > 0, "corrigé : à 501 ms, la série est encore vue");
|
||||
assertTrue(serieHitboxAvecPing(5000) > 0, "corrigé : à 5 s déclarées aussi (fenêtre bornée)");
|
||||
}
|
||||
|
||||
// --- Revue n°2 / C13 : regard et œil du paquet SUIVANT acceptés sans borne --------------------------------------
|
||||
|
||||
@Test
|
||||
void FAILLE_revue2_regardSuivantRameneSurLaCibleEffaceLeCoupHorsBoite() {
|
||||
void CORRIGE_revue2_regardSuivantRameneSurLaCibleNEffacePlusLeCoupHorsBoite() {
|
||||
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||
double temoin = 0, triche = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
@@ -107,11 +108,11 @@ class AutotestContournementsTest {
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
assertTrue(temoin > 0, "témoin : le même regard gardé au paquet suivant est vu");
|
||||
assertEquals(0, triche, 1e-9, "prouvé : un demi-tour du regard au paquet suivant efface tout (aucune borne d'angle)");
|
||||
assertTrue(triche > 0, "corrigé : un demi-tour du regard au paquet suivant n'est plus accepté");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_revue2_oeilSuivantAvanceDe09BlocEffaceLaPorteeAllongee() {
|
||||
void CORRIGE_revue2_oeilSuivantAvanceDe09BlocNEffacePlusLaPorteeAllongee() {
|
||||
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||
double temoin = 0, triche = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
@@ -131,11 +132,11 @@ class AutotestContournementsTest {
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
assertTrue(temoin > 0);
|
||||
assertEquals(0, triche, 1e-9, "prouvé : l'œil suivant n'est pas borné à un déplacement légal");
|
||||
assertTrue(triche > 0, "corrigé : l'œil suivant est borné à un déplacement d'un tick");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C13_porteeEtHitboxGardentLeMinimumAvecLePaquetSuivant() {
|
||||
void CORRIGE_C13_porteeEtAngleNeGardentPlusLeMinimumSansBorne() {
|
||||
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
|
||||
double[] b = boite(0);
|
||||
double[] loin = {0, 1.62, -4.3}; // 4,0 blocs de la boîte : refus vanilla à la limite
|
||||
@@ -151,49 +152,88 @@ class AutotestContournementsTest {
|
||||
List<Verdict> v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), loin, regard, b, 3.0, 0,
|
||||
true, false));
|
||||
v.addAll(moteur.regardPorteeHitbox(joueur, 50, proche, vers(proche, 0, 1.0, 0)));
|
||||
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "prouvé : s'avancer au paquet suivant efface la portée");
|
||||
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)));
|
||||
assertEquals(0, points(a, Controle.KILLAURA_ANGLE), 1e-9, "prouvé : rotation silencieuse 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");
|
||||
}
|
||||
|
||||
/**
|
||||
* C13, seuils de {@code portee} (3,3 sur cible immobile, 4,3 sur cible qui sprinte) : {@code portee} et
|
||||
* {@code hitbox} ne sont pas resserrés (ils peuvent être en ENFORCE en production ; tolérance « vitesse × ticks »
|
||||
* gardée). C'est {@code coups-hors-boite} (mesure sur l'historique de la cible, marge 0,15) qui doit voir ces
|
||||
* reach en série. Ancien test : {@code FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee},
|
||||
* qui mesurait {@code portee} seul. [À VÉRIFIER] Théo : accepter que la correction passe par coups-hors-boite.
|
||||
*/
|
||||
@Test
|
||||
void FAILLE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteSousLeSeuilPortee() {
|
||||
cfg.mode(Controle.COUPS_HORS_BOITE, Mode.OFF);
|
||||
double[] b = boite(0);
|
||||
double[] oeil33 = {0, 1.62, -3.59}; // 3,29 blocs
|
||||
List<Verdict> v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil33,
|
||||
vers(oeil33, 0, 1.0, 0), b, 3.0, 0, true, false));
|
||||
v.addAll(moteur.terminerCoup(joueur));
|
||||
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,29 blocs sur cible immobile : rien");
|
||||
|
||||
void CORRIGE_C13_reachDe33SurCibleImmobileEtDe40SurCibleQuiSprinteVusParCoupsHorsBoite() {
|
||||
int fenetre = PorteeHitbox.ticksFenetre(30, cfg);
|
||||
double immobile = 0, sprint = 0, honnete = 0;
|
||||
for (int k = 0; k < 10; k++) {
|
||||
double x = 5 * k;
|
||||
double[][] fixes = new double[fenetre + 2][];
|
||||
for (int i = 0; i < fixes.length; i++) fixes[i] = boite(x);
|
||||
double[] oeil33 = {x, 1.62, -3.59}; // 3,29 blocs, cible immobile
|
||||
immobile += points(coupV(k * 600L, oeil33, vers(oeil33, x, 1.0, 0), x, 0, fixes), Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
moteur = new Moteur(cfg);
|
||||
double[] oeil40 = {0, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte
|
||||
v = new ArrayList<>(moteur.coupDiffere(joueur, 0, EtatJoueur.normal(), oeil40, vers(oeil40, 0, 1.0, 0), b, 3.0,
|
||||
V, true, false));
|
||||
v.addAll(moteur.terminerCoup(joueur));
|
||||
assertEquals(0, points(v, Controle.PORTEE), 1e-9, "3,99 blocs sur cible qui sprinte : rien pour portee");
|
||||
for (int k = 0; k < 10; k++) {
|
||||
double x = 5 * k;
|
||||
double[] oeil40 = {x, 1.62, -4.29}; // 3,99 blocs, cible qui sprinte
|
||||
sprint += points(coupV(k * 600L, oeil40, vers(oeil40, x, 1.0, 0), x, V, vues(x, fenetre)),
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
moteur = new Moteur(cfg);
|
||||
for (int k = 0; k < 10; k++) {
|
||||
double x = 5 * k;
|
||||
double[] oeil = {x, 1.62, -3.2}; // 2,9 blocs : honnête
|
||||
honnete += points(coupV(k * 600L, oeil, vers(oeil, x, 1.0, 0), x, V, vues(x, fenetre)),
|
||||
Controle.COUPS_HORS_BOITE);
|
||||
}
|
||||
assertTrue(immobile > 0, "3,29 blocs sur cible immobile : vu en série");
|
||||
assertTrue(sprint > 0, "3,99 blocs sur cible qui sprinte : vu en série");
|
||||
assertEquals(0, honnete, 1e-9, "témoin : 2,9 blocs, rien");
|
||||
}
|
||||
|
||||
private List<Verdict> coupV(long t, double[] oeil, double[] regard, double xCible, double vCible, double[][] vues) {
|
||||
List<Verdict> vs = new ArrayList<>(moteur.coupDiffere(joueur, t, EtatJoueur.normal(), oeil, regard,
|
||||
boite(xCible), 3.0, vCible, true, false, oeil, vues));
|
||||
vs.addAll(moteur.regardPorteeHitbox(joueur, t + 50, oeil, regard));
|
||||
return vs;
|
||||
}
|
||||
|
||||
// --- Revue n°4 : la fenêtre d'historique grandit avec le ping déclaré ------------------------------------------
|
||||
|
||||
private double serieDerriereLaCible(int ping) {
|
||||
/** Le joueur a eu {@code pingAvant} pendant une minute, puis déclare {@code ping} pendant le combat. */
|
||||
private double serieDerriereLaCible(int pingAvant, int ping) {
|
||||
moteur = new Moteur(cfg);
|
||||
for (long t = 0; t < 60_000; t += 1000) moteur.pingFenetre(joueur, t, pingAvant);
|
||||
EtatJoueur etat = EtatJoueur.builder().pingMs(ping).build();
|
||||
int fenetre = PorteeHitbox.ticksFenetre(ping, cfg); // ce que Garde.boitesVues calcule depuis latency()
|
||||
// ce que Garde.boitesVues calcule depuis latency()
|
||||
int fenetre = PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 60_000, ping), cfg);
|
||||
double total = 0;
|
||||
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);
|
||||
}
|
||||
@@ -201,13 +241,21 @@ class AutotestContournementsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_revue4_pingDeclareA450msElargitLaFenetreEtCacheLaTriche() {
|
||||
void CORRIGE_revue4_pingGonflePendantLeCombatNElargitPlusLaFenetre() {
|
||||
assertEquals(8, PorteeHitbox.ticksFenetre(30, cfg));
|
||||
assertEquals(16, PorteeHitbox.ticksFenetre(450, cfg));
|
||||
assertEquals(17, PorteeHitbox.ticksFenetre(500, cfg));
|
||||
assertTrue(serieDerriereLaCible(30) > 0, "témoin : à 30 ms, la série est vue");
|
||||
assertEquals(0, serieDerriereLaCible(450), 1e-9,
|
||||
"prouvé : le même client qui annonce 450 ms de ping n'est plus vu (fenêtre 16 ticks au lieu de 8)");
|
||||
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.
|
||||
moteur = new Moteur(cfg);
|
||||
assertEquals(16, PorteeHitbox.ticksFenetre(moteur.pingFenetre(joueur, 0, 450), cfg));
|
||||
}
|
||||
|
||||
// --- C15 : vitesse 0,40 en l'air et Timer 1,09 non vus ---------------------------------------------------------
|
||||
@@ -230,16 +278,21 @@ class AutotestContournementsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C15_bhopA040BlocParTickNestJamaisVu() {
|
||||
// 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (un sprint-saut honnête fait en moyenne ~0,28 à 0,33).
|
||||
assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9);
|
||||
void CORRIGE_C15_bhopA040BlocParTickEstVuAvecLOption() {
|
||||
// Option désactivée par défaut : comportement inchangé.
|
||||
assertEquals(0, vitesse(0.40, 0.40, 12, 400), 1e-9, "option coupée : rien (comme avant)");
|
||||
cfg.vitesseMoyenne = true;
|
||||
// 1 tick au sol, 11 en l'air, à 0,40 bloc/tick (sprint-saut vanilla : ~0,356 en moyenne, 7,13 m/s).
|
||||
assertTrue(vitesse(0.40, 0.40, 12, 400) > 0, "corrigé : bhop à 0,40 vu");
|
||||
assertEquals(0, vitesse(0.356, 0.356, 12, 400), 1e-9, "témoin : sprint-saut vanilla moyen, rien");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C15_speedAuSolA037BlocParTickNestJamaisVu() {
|
||||
void CORRIGE_C15_speedAuSolA037BlocParTickEstVuAvecLOption() {
|
||||
assertTrue(vitesse(0.45, 0.45, 1, 200) > 0, "témoin : 0,45 au sol (+50 %) est vu");
|
||||
// 0,37 au sol : +23 % sur le sprint (0,30), l'excès (0,06/tick) reste sous le tampon de 1,5 bloc / 20 ticks.
|
||||
assertEquals(0, vitesse(0.37, 0.37, 1, 400), 1e-9);
|
||||
cfg.vitesseMoyenne = true;
|
||||
assertTrue(vitesse(0.37, 0.37, 1, 400) > 0, "corrigé : 0,37 au sol vu");
|
||||
assertEquals(0, vitesse(0.28, 0.28, 1, 400), 1e-9, "témoin : sprint vanilla (0,28), rien");
|
||||
}
|
||||
|
||||
private double timer(long intervalleMs, int secondes) {
|
||||
@@ -252,8 +305,24 @@ class AutotestContournementsTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C15_timerA109NestJamaisVu() {
|
||||
void CORRIGE_C15_timerA109EstVuAvecLOption() {
|
||||
assertTrue(timer(40, 10) > 0, "témoin : 25 paquets/s (timer 1,25) est vu");
|
||||
assertEquals(0, timer(46, 30), 1e-9, "prouvé : 21,7 paquets/s (timer 1,09) pendant 30 s, aucun point");
|
||||
assertEquals(0, timer(46, 30), 1e-9, "option coupée : rien (comme avant)");
|
||||
cfg.timerSoldeMax = 20;
|
||||
assertTrue(timer(46, 30) > 0, "corrigé : 21,7 paquets/s (timer 1,09) pendant 30 s vu par le solde");
|
||||
assertEquals(0, timer(50, 60), 1e-9, "témoin : 20 paquets/s, rien");
|
||||
// Témoin lag : 1 s sans paquet, puis rafale de 20 paquets d'un coup, à répéter.
|
||||
moteur = new Moteur(cfg);
|
||||
double lag = 0;
|
||||
long t = 10_000;
|
||||
for (int r = 0; r < 20; r++) {
|
||||
t += 1000;
|
||||
for (int i = 0; i < 20; i++) lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER);
|
||||
for (int i = 0; i < 40; i++) {
|
||||
t += 50;
|
||||
lag += points(moteur.paquetMouvement(joueur, t, EtatJoueur.normal()), Controle.TIMER);
|
||||
}
|
||||
}
|
||||
assertEquals(0, lag, 1e-9, "témoin : rafales de rattrapage après un lag, rien");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package com.gastinelgarde.core;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* Autotests du 16/10/2026 : rafales réseau (paquets de mouvement groupés après un lag). Chaque paquet couvre UN tick
|
||||
* client, mais le serveur voit {@code motif[i]} ticks écoulés avant lui (3, 0, 0 : trois paquets arrivés ensemble).
|
||||
*
|
||||
* {@code CORRIGE_…} : anciens FAUX_POSITIF_ (joueur honnête puni), inversés : aucun point attendu.
|
||||
* {@code temoin_…} : la triche équivalente (chute ralentie) doit rester vue, avant comme après le correctif.
|
||||
*/
|
||||
class AutotestRafalesTest {
|
||||
|
||||
private Moteur moteur;
|
||||
private final UUID joueur = UUID.randomUUID();
|
||||
private long tick;
|
||||
private boolean sanctionLourde;
|
||||
|
||||
@BeforeEach
|
||||
void init() {
|
||||
GardeConfig cfg = new GardeConfig();
|
||||
cfg.mode(Controle.VOL, Mode.ENFORCE);
|
||||
cfg.mode(Controle.VITESSE, Mode.OFF);
|
||||
cfg.mode(Controle.NO_FALL, Mode.OBSERVE);
|
||||
moteur = new Moteur(cfg);
|
||||
tick = 5000;
|
||||
sanctionLourde = false;
|
||||
}
|
||||
|
||||
private static EtatMouvement m(double dy, int ticks, boolean sol) {
|
||||
return new EtatMouvement(0.1, dy, ticks, sol, sol, false, false, false, 0, 0, false, false);
|
||||
}
|
||||
|
||||
private double paquet(EtatMouvement mv) {
|
||||
tick += mv.ticks();
|
||||
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, EtatJoueur.normal(), mv);
|
||||
double p = 0;
|
||||
for (Verdict v : vs) {
|
||||
if (v.controle() == Controle.VOL) p += v.points();
|
||||
if (v.palier() == Sanction.SETBACK || v.palier() == Sanction.EXPULSION) sanctionLourde = true;
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
/** Chute honnête de {@code paquets} ticks client depuis la vitesse v0, avec la gigue donnée. */
|
||||
private double chute(double v0, int paquets, int[] motif) {
|
||||
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
|
||||
double total = 0, v = v0;
|
||||
for (int p = 0; p < paquets; p++) {
|
||||
total += paquet(m(v, motif[p % motif.length], false));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
return total;
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_rafalesDeTroisLongueChuteSansPointNiSanction() {
|
||||
double total = chute(0, 80, new int[] {3, 0, 0});
|
||||
Mesures.noter("Rafales 3,0,0 chute 80 : " + total + " points, sanction lourde=" + sanctionLourde);
|
||||
assertEquals(0, total, 1e-9);
|
||||
assertTrue(!sanctionLourde, "aucun setback ni expulsion pour un joueur honnête");
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_sautPuisChuteEnRafalesDeTrois() {
|
||||
double total = chute(0.42, 80, new int[] {3, 0, 0});
|
||||
Mesures.noter("Rafales 3,0,0 saut + chute 80 : " + total + " points");
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_gigueIrreguliereApresUnLag() {
|
||||
// Gigue irrégulière (rafales de 3 et 4 mêlées) : mesurée à 0 point avant le correctif, doit le rester.
|
||||
double total = chute(0, 90, new int[] {3, 0, 0, 4, 0, 0, 0, 1, 2, 0, 3, 0, 0});
|
||||
Mesures.noter("Gigue irreguliere chute 90 : " + total + " points");
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void temoin_chuteRalentieUnPaquetDUnTickToutesLesTroisTicksResteVue() {
|
||||
// Triche « slow fall / timer lent » : un paquet d'un tick de gravité toutes les 3 ticks serveur, sans rattrapage.
|
||||
double total = chute(0, 80, new int[] {3});
|
||||
Mesures.noter("Temoin chute ralentie 1/3 : " + total + " points");
|
||||
assertTrue(total > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void temoin_planeEnRafalesResteVu() {
|
||||
// Plané (dy = 0) livré en rafales : doit être vu, quelle que soit la gigue.
|
||||
for (int i = 0; i < 3; i++) paquet(m(0, 1, true));
|
||||
double total = 0;
|
||||
int[] motif = {3, 0, 0};
|
||||
for (int p = 0; p < 60; p++) total += paquet(m(-0.01, motif[p % 3], false));
|
||||
assertTrue(total > 0);
|
||||
}
|
||||
|
||||
@Test
|
||||
void honnete_chuteSansGigueReference() {
|
||||
assertEquals(0, chute(0, 80, new int[] {1}), 1e-9);
|
||||
}
|
||||
}
|
||||
@@ -14,9 +14,9 @@ import org.junit.jupiter.api.Test;
|
||||
/**
|
||||
* Autotests du 16/10/2026, nuit : incident VOL de Rednixxu (15/10, 17:31) et constats C1 à C5, C10 de l'autocritique.
|
||||
*
|
||||
* Ces tests DOCUMENTENT le comportement actuel, ils ne corrigent rien : un test nommé {@code FAILLE_…} ou
|
||||
* {@code FAUX_POSITIF_…} passe tant que le défaut existe. Quand le défaut sera corrigé, il échouera : il faudra alors
|
||||
* inverser son assertion (c'est voulu, pour que la correction soit vue).
|
||||
* C1 à C5 corrigés le 16/10 (branche fix/vol-elytres) : les anciens tests {@code FAUX_POSITIF_…} / {@code FAILLE_…}
|
||||
* ont été inversés et renommés {@code CORRIGE_…}. C10 corrigé le 16/10 (branche fix/hitbox-c10-c13-c15) par une option
|
||||
* désactivée par défaut ({@code volFenetreGlissante}) : ses tests l'activent et gardent un témoin honnête.
|
||||
*
|
||||
* Ce qui se passe dans l'adaptateur (Garde.java, qui dépend de Minecraft) est rejoué ici par un petit modèle écrit
|
||||
* d'après le code : position mémorisée après un paquet sans verdict (Garde.apresMouvement), paquet suivant un
|
||||
@@ -67,7 +67,8 @@ class AutotestVolIncidentTest {
|
||||
tick++;
|
||||
y += m.dy();
|
||||
List<Verdict> vs = moteur.mouvement(joueur, tick * 50L, e, m);
|
||||
if (vs.isEmpty()) { // Garde.apresMouvement : m.dernierVerdictTick != tick
|
||||
// Garde.apresMouvement : m.dernierVerdictTick != tick, et (16/10, C3) position admise (au sol serveur)
|
||||
if (vs.isEmpty() && moteur.positionDeRetourAdmise(m.auSolServeur(), m.milieuSpecial())) {
|
||||
yRetour = y;
|
||||
retourAuSol = m.auSolServeur();
|
||||
}
|
||||
@@ -94,24 +95,46 @@ class AutotestVolIncidentTest {
|
||||
return sortie;
|
||||
}
|
||||
|
||||
// --- C1 : pas de grâce de sortie d'élytres pour le vol ----------------------------------------------------------
|
||||
/** Plané anormal depuis le sol, sans élytres (triche de type « glide ») : de quoi déclencher des setbacks. */
|
||||
private EtatMouvement plane() {
|
||||
return air(-0.02);
|
||||
}
|
||||
|
||||
// --- C1 : grâce de sortie d'élytres pour le vol (corrigé le 16/10) ----------------------------------------------
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C1_planeDElytresDontLeDrapeauTombeEstPrisPourDuVol() {
|
||||
void CORRIGE_C1_planeDElytresDontLeDrapeauTombeNEstPlusPrisPourDuVol() {
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
|
||||
int premier = -1;
|
||||
double total = 0;
|
||||
for (int k = 0; k < vs.size(); k++) {
|
||||
double p = points(vs.get(k), Controle.VOL);
|
||||
if (p > 0 && premier < 0) premier = k + 1;
|
||||
total += p;
|
||||
for (List<Verdict> v : vs) total += points(v, Controle.VOL);
|
||||
// Avant : premier point au 12e tick, 11,6 points en 19 ticks (incident de Rednixxu).
|
||||
assertEquals(0, total, 1e-9, "grâce de fin d'élytres : la trace de Rednixxu ne donne plus rien");
|
||||
Mesures.noter("C1 corrige : 19 ticks de plane sans drapeau = " + total + " point");
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_C1_laGraceDeFinDElytresEstBorneeDansLeTemps() {
|
||||
// Témoin : un plané sans drapeau qui dure bien au-delà de la grâce finit par être vu.
|
||||
// 16/10 : témoin corrigé. L'ancien (accélération 0,02 bloc/tick² prolongée) entre dans la tolérance de
|
||||
// VolVertical (0,05) dès ~22 ticks et n'était donc jamais puni après 50 ticks de grâce, même sans grâce.
|
||||
// Plané constant à -0,05 bloc/tick : écart ~0,077 à chaque tick, nettement anormal.
|
||||
sautPuisPlaneSansDrapeau(1);
|
||||
double total = 0;
|
||||
for (int k = 0; k < cfg.graceFinElytresTicks + 30; k++) {
|
||||
total += points(paquet(EtatJoueur.normal(), air(-0.05)), Controle.VOL);
|
||||
}
|
||||
// Prouvé : le 1er paquet après l'exemption sert de référence, les suivants sont tous « anormaux » ; le 12e tick
|
||||
// de plané sans drapeau donne le premier point (journal réel : 13 ticks après la chute du drapeau, vl=1.1).
|
||||
assertEquals(12, premier, "premier tick de plané puni");
|
||||
assertEquals(1.1, points(vs.get(11), Controle.VOL), 1e-9);
|
||||
assertTrue(total > cfg.seuilSetback, "19 ticks de plané suffisent à dépasser le seuil de setback");
|
||||
Mesures.noter("C1 premier point au tick " + premier + " de plane sans drapeau ; total 19 ticks = " + total);
|
||||
assertTrue(total > 0, "après la grâce, un plané anormal est de nouveau puni");
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_C1_laGraceSeTermineALAtterrissage() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 20; i++) paquet(elytres, air(-0.3));
|
||||
for (int i = 0; i < 3; i++) paquet(EtatJoueur.normal(), sol()); // atterrissage : fin de la grâce
|
||||
double total = 0;
|
||||
for (int i = 0; i < 20; i++) total += points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL);
|
||||
assertTrue(total > 0, "voler juste après un atterrissage d'élytres reste vu");
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -127,102 +150,94 @@ class AutotestVolIncidentTest {
|
||||
assertEquals(0, total, 1e-9, "réfuté : une fin d'élytres suivie d'une chute vanilla ne donne rien");
|
||||
}
|
||||
|
||||
// --- C3 : point de retour mémorisé en l'air -----------------------------------------------------------------------
|
||||
// --- C3 : point de retour au sol (corrigé le 16/10) --------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C3_pointDeRetourMemoriseEnLAirSousLaPlateforme() {
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(12);
|
||||
assertTrue(points(vs.get(11), Controle.VOL) > 0);
|
||||
assertFalse(retourAuSol, "la position de retour vient d'un paquet en l'air");
|
||||
assertTrue(yRetour < Y_SOL, "et elle est sous la plateforme d'où il a sauté : " + yRetour);
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT,
|
||||
"C3 retour en l'air a y=%.3f (sol %.3f, ecart %.3f ; journal reel : 109,685, ecart 1,19)",
|
||||
yRetour, Y_SOL, Y_SOL - yRetour));
|
||||
void CORRIGE_C3_pointDeRetourResteAuSolPendantUnPlane() {
|
||||
sautPuisPlaneSansDrapeau(12);
|
||||
assertTrue(retourAuSol, "la position de retour vient d'un paquet au sol serveur");
|
||||
assertEquals(Y_SOL, yRetour, 1e-9, "et c'est la plateforme d'où il a sauté");
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C3_unVolDeDixTicksGardeLAltitudeGagneeDansLePointDeRetour() {
|
||||
void CORRIGE_C3_unVolDeDixTicksNeGardePasLAltitudeGagnee() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
int premier = -1;
|
||||
for (int k = 1; k <= 15 && premier < 0; k++) {
|
||||
if (points(paquet(EtatJoueur.normal(), air(0.1)), Controle.VOL) > 0) premier = k;
|
||||
}
|
||||
assertTrue(premier > 10, "le vol n'est vu qu'après 10 ticks anormaux");
|
||||
assertFalse(retourAuSol);
|
||||
assertTrue(yRetour - Y_SOL >= 0.9, "le setback ramène à l'altitude gagnée en volant : +" + (yRetour - Y_SOL));
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT, "C3 tricheur : retour a +%.2f bloc au-dessus du sol",
|
||||
yRetour - Y_SOL));
|
||||
assertTrue(retourAuSol);
|
||||
assertEquals(Y_SOL, yRetour, 1e-9, "le setback ramène au sol de départ, pas à l'altitude gagnée");
|
||||
}
|
||||
|
||||
// --- C2, C5, C4 : setback sans remise à zéro, escalade en moins d'une seconde, expulsion répétée ------------------
|
||||
// --- C2, C5, C4 : setback remis à zéro, escalade, expulsion unique (corrigés le 16/10) ---------------------------
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C2_setbackNOuvreAucuneGraceEtNeRemetPasLeVolAZero() {
|
||||
GraceTeleport g = new GraceTeleport();
|
||||
g.annoncer(GraceTeleport.Origine.SETBACK);
|
||||
assertFalse(g.teleport(), "le setback n'ouvre pas la grâce de téléportation");
|
||||
|
||||
List<List<Verdict>> vs = sautPuisPlaneSansDrapeau(19);
|
||||
int k = 0;
|
||||
while (Verdict.pire(vs.get(k)) != Sanction.SETBACK) k++; // premier SETBACK
|
||||
// Modèle de l'adaptateur : teleport() vers le point de retour ; le paquet suivant n'est pas mesuré.
|
||||
tick++;
|
||||
/** Modèle de Garde.appliquerSanctionMouvement (SETBACK) : téléportation au point de retour puis remise à zéro. */
|
||||
private void setback() {
|
||||
moteur.apresSetback(joueur, tick * 50L);
|
||||
tick++; // teleport() : le paquet suivant n'est pas mesuré (Garde.teleportVanilla)
|
||||
y = yRetour;
|
||||
// Joueur gelé en l'air au point de retour (dy = 0, gravité absente tant que la téléportation n'est pas
|
||||
// confirmée : « kicked for floating too long » x302 dans le journal du 15/10).
|
||||
for (int i = 0; i < 5; i++) {
|
||||
List<Verdict> v = paquet(EtatJoueur.normal(), air(0));
|
||||
assertTrue(points(v, Controle.VOL) > 0, "paquet gelé " + i + " après le setback encore puni");
|
||||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAUX_POSITIF_C5_C4_cinqSetbacksPuisExpulsionEnMoinsDUneSecondeEtExpulsionRepetee() {
|
||||
void CORRIGE_C2_apresUnSetbackLeVolEtLesVlRepartentDeZero() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double v = 0.42;
|
||||
int n = 0;
|
||||
while (Verdict.pire(paquet(EtatJoueur.normal(), plane())) != Sanction.SETBACK) assertTrue(++n < 100);
|
||||
assertTrue(retourAuSol, "point de retour au sol");
|
||||
setback();
|
||||
assertEquals(0, moteur.suivi(joueur).vl.valeur(Controle.VOL, tick * 50L), 1e-9, "VL de vol remis à zéro");
|
||||
// Le client, ramené au sol, reste immobile quelques paquets (téléportation pas encore confirmée) : rien.
|
||||
for (int i = 0; i < 5; i++) {
|
||||
paquet(EtatJoueur.normal(), air(v));
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
List<Verdict> v = paquet(EtatJoueur.normal(), sol());
|
||||
assertEquals(0, points(v, Controle.VOL), 1e-9, "paquet " + i + " après le setback");
|
||||
}
|
||||
EtatJoueur elytres = EtatJoueur.builder().elytres(true).build();
|
||||
for (int i = 0; i < 7; i++) paquet(elytres, air(-0.05));
|
||||
// Et même gelé en l'air une demi-seconde (ancien scénario), le compteur repart de zéro : pas de point.
|
||||
double total = 0;
|
||||
for (int i = 0; i < 10; i++) total += points(paquet(EtatJoueur.normal(), air(0)), Controle.VOL);
|
||||
assertEquals(0, total, 1e-9);
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_C5_C4_escaladeEnPlusDUneSecondeEtExpulsionUnique() {
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
int premierPointTick = -1, setbacks = 0, expulsionTick = -1;
|
||||
double dyPlane = 0;
|
||||
boolean gele = false;
|
||||
for (int n = 0; n < 200 && expulsionTick < 0; n++) {
|
||||
EtatMouvement m;
|
||||
if (gele) {
|
||||
m = air(0);
|
||||
} else {
|
||||
dyPlane -= 0.02;
|
||||
m = air(dyPlane);
|
||||
}
|
||||
List<Verdict> vs = paquet(EtatJoueur.normal(), m);
|
||||
for (int n = 0; n < 2000 && expulsionTick < 0; n++) {
|
||||
List<Verdict> vs = paquet(EtatJoueur.normal(), plane());
|
||||
if (points(vs, Controle.VOL) > 0 && premierPointTick < 0) premierPointTick = tick;
|
||||
Sanction s = Verdict.pire(vs);
|
||||
if (s == Sanction.SETBACK) {
|
||||
setbacks++;
|
||||
gele = true;
|
||||
tick++; // teleport() : le paquet suivant n'est pas mesuré (Garde.teleportVanilla)
|
||||
y = yRetour;
|
||||
setback();
|
||||
paquet(EtatJoueur.normal(), sol()); // de retour au sol, le tricheur recommence
|
||||
} else if (s == Sanction.EXPULSION) {
|
||||
expulsionTick = tick;
|
||||
}
|
||||
}
|
||||
assertTrue(expulsionTick > 0, "expulsion atteinte");
|
||||
assertTrue(expulsionTick > 0, "un tricheur obstiné finit expulsé");
|
||||
int duree = expulsionTick - premierPointTick;
|
||||
Mesures.noter("C5 premier point -> expulsion : " + duree + " ticks (" + duree * 50 + " ms), " + setbacks
|
||||
+ " setbacks (journal reel : 5 setbacks, expulsion a la 1re seconde)");
|
||||
assertTrue(duree < 20, "moins d'une seconde entre le premier point et l'expulsion : " + duree + " ticks");
|
||||
assertTrue(setbacks >= 3 && setbacks <= 6, "quelques setbacks seulement : " + setbacks);
|
||||
Mesures.noter("C5 corrige : premier point -> expulsion : " + duree + " ticks (" + duree * 50 + " ms), "
|
||||
+ setbacks + " setbacks");
|
||||
assertTrue(duree >= 40, "au moins 2 s entre le premier point et l'expulsion : " + duree + " ticks");
|
||||
assertEquals(cfg.setbacksAvantExpulsion, setbacks, "l'expulsion vient après plusieurs setbacks distincts");
|
||||
|
||||
// C4 (partie moteur) : rien ne retient « déjà expulsé » ; chaque paquet suivant redonne une EXPULSION.
|
||||
int expulsionsSuivantes = 0;
|
||||
for (int i = 0; i < 20; i++) {
|
||||
if (Verdict.pire(paquet(EtatJoueur.normal(), air(0))) == Sanction.EXPULSION) expulsionsSuivantes++;
|
||||
}
|
||||
assertEquals(20, expulsionsSuivantes, "chaque paquet après l'expulsion rend encore EXPULSION");
|
||||
// C4 : l'expulsion est à usage unique ; le moteur ne rend plus rien pour ce joueur.
|
||||
assertTrue(moteur.expulser(joueur, tick * 50L), "première expulsion acceptée");
|
||||
assertFalse(moteur.expulser(joueur, tick * 50L), "deuxième demande refusée");
|
||||
int verdictsSuivants = 0;
|
||||
for (int i = 0; i < 20; i++) verdictsSuivants += paquet(EtatJoueur.normal(), plane()).size();
|
||||
assertEquals(0, verdictsSuivants, "aucun verdict après l'expulsion");
|
||||
// C6 : même si l'état du joueur est retiré pendant disconnect(), la marque d'expulsion reste.
|
||||
moteur.retirer(joueur);
|
||||
assertFalse(moteur.expulser(joueur, tick * 50L));
|
||||
moteur.oublierExpulsion(joueur); // reconnexion
|
||||
assertTrue(moteur.expulser(joueur, tick * 50L));
|
||||
}
|
||||
|
||||
@Test
|
||||
void jamaisDeBannissement() {
|
||||
for (Sanction s : Sanction.values()) assertFalse(s.name().contains("BAN"), "sanction " + s);
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -238,7 +253,8 @@ class AutotestVolIncidentTest {
|
||||
// --- C10 : sauts en l'air espacés --------------------------------------------------------------------------------
|
||||
|
||||
@Test
|
||||
void FAILLE_C10_unSautEnLAirTousLesDixTicksMonteSansFinSansAucunPoint() {
|
||||
void CORRIGE_C10_unSautEnLAirTousLesDixTicksEstVuAvecLOption() {
|
||||
cfg.volFenetreGlissante = true;
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double total = 0;
|
||||
double depart = y;
|
||||
@@ -249,14 +265,32 @@ class AutotestVolIncidentTest {
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
}
|
||||
assertEquals(0, total, 1e-9, "prouvé : aucun point");
|
||||
// ~0,5 bloc gagné par cycle de 10 ticks : ~15 blocs en 15 s, sans limite.
|
||||
assertTrue(y - depart > 10, "et le tricheur a gagné " + (y - depart) + " blocs en 15 s");
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT, "C10 : +%.1f blocs en 300 ticks, 0 point", y - depart));
|
||||
assertTrue(total > 0, "corrigé : les sauts en l'air répétés sont vus");
|
||||
Mesures.noter(String.format(java.util.Locale.ROOT, "C10 corrige : %.1f points en 300 ticks", total));
|
||||
}
|
||||
|
||||
@Test
|
||||
void FAILLE_C10_alternerUnTickAnormalEtUnTickNormalPlaneSansPoint() {
|
||||
void CORRIGE_C10_temoinSautsHonnetesRepetesAvecLOption() {
|
||||
cfg.volFenetreGlissante = true;
|
||||
double total = 0;
|
||||
for (int cycle = 0; cycle < 30; cycle++) {
|
||||
total += points(paquet(EtatJoueur.normal(), sol()), Controle.VOL);
|
||||
double v = 0.42; // saut depuis le sol
|
||||
double h = 0;
|
||||
for (int i = 0; i < 40; i++) {
|
||||
if (h + v <= 0) break; // retour au sol
|
||||
h += v;
|
||||
total += points(paquet(EtatJoueur.normal(), air(v)), Controle.VOL);
|
||||
v = (v - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
}
|
||||
y = Y_SOL;
|
||||
}
|
||||
assertEquals(0, total, 1e-9, "témoin : sauts honnêtes répétés, rien");
|
||||
}
|
||||
|
||||
@Test
|
||||
void CORRIGE_C10_alternerUnTickAnormalEtUnTickNormalEstVuAvecLOption() {
|
||||
cfg.volFenetreGlissante = true;
|
||||
for (int i = 0; i < 5; i++) paquet(EtatJoueur.normal(), sol());
|
||||
double total = 0;
|
||||
double depart = y;
|
||||
@@ -265,8 +299,6 @@ class AutotestVolIncidentTest {
|
||||
double dy = i % 2 == 0 ? -0.02 : (-0.02 - VolVertical.GRAVITE) * VolVertical.TRAINEE;
|
||||
total += points(paquet(EtatJoueur.normal(), air(dy)), Controle.VOL);
|
||||
}
|
||||
assertEquals(0, total, 1e-9);
|
||||
// 200 ticks de chute vanilla depuis l'arrêt : plus de 200 blocs. Ici : ~6 blocs.
|
||||
assertTrue(depart - y < 15, "descente de " + (depart - y) + " blocs en 10 s (chute lente illimitée)");
|
||||
assertTrue(total > 0, "corrigé : l'alternance plané / gravité est vue");
|
||||
}
|
||||
}
|
||||
@@ -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