GastinelGarde vol : correctif incident elytres du 15/10 (C1-C5)
C1 grace du controle vol apres la fin du plane en elytres (bornee, finie a l atterrissage). C2 setback : vol et vitesse remis a zero, VL VOL/VITESSE a zero. C3 position de retour seulement au sol serveur ou milieu special. C4 expulsion a usage unique jusqu a la reconnexion, plus aucune evaluation entre-temps. C5 expulsion seulement apres plusieurs setbacks recents. Jamais de bannissement. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Cette révision appartient à :
1 Parent
56a98f3a5c
révision
9335654541
5 fichiers modifiés
+95
-9
Aucun fichier ne correspond à votre recherche
@@ -547,6 +547,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 +558,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 +603,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 +874,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 +884,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
|
||||
|
||||
@@ -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;
|
||||
@@ -224,6 +229,7 @@ public final class Moteur {
|
||||
|
||||
/** 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);
|
||||
@@ -270,6 +276,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 +292,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 +312,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 +324,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);
|
||||
@@ -328,7 +341,15 @@ public final class Moteur {
|
||||
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) {
|
||||
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 +371,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();
|
||||
@@ -397,22 +419,45 @@ public final class Moteur {
|
||||
|
||||
// --- Setback, expulsion, position de retour (16/10, incident VOL) ----------------------------------------
|
||||
|
||||
/** Un retour en arrière vient d'être appliqué (squelette, pas encore de comportement). */
|
||||
/**
|
||||
* 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);
|
||||
}
|
||||
|
||||
/** Demande d'expulsion (squelette). */
|
||||
/**
|
||||
* 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 true;
|
||||
return expulses.add(joueur);
|
||||
}
|
||||
|
||||
/** Reconnexion (squelette). */
|
||||
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);
|
||||
}
|
||||
|
||||
/** La position de ce paquet peut-elle servir de retour en arrière ? (squelette) */
|
||||
/**
|
||||
* 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 true;
|
||||
return auSolServeur || milieuSpecial;
|
||||
}
|
||||
|
||||
// --- Interne ----------------------------------------------------------------------------------------
|
||||
@@ -423,6 +468,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);
|
||||
|
||||
@@ -21,6 +21,22 @@ public final class Suivi {
|
||||
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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur