P1.2 : grace de connexion, plus longue apres une expulsion, setback au sol

- Grace de connexion (mouvement, vehicule, timer ; pas le combat) :
  graceConnexionTicks (100), graceApresExpulsionTicks (200) si expulse il y a
  moins de 10 min (Moteur.graceConnexionTicks, memoire qui survit a la
  reconnexion). Ligne de journal a la reconnexion apres expulsion.
- Sans position de retour valide, le SETBACK ramene au sol juste sous le
  joueur (meme x, z, au plus 64 blocs, jamais vers le haut ni de cote) :
  setbackSolSiPasDePosition (true). Sinon « SETBACK impossible » (P1.1).
- Nouvelle section [graces].
- Tests : ReconnexionP1Test.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Sonnet 5.5 a révisé 2026-10-24 00:22:09 +02:00
1 Parent b72e5717c5
révision 7b19f86ff9
10 fichiers modifiés
+226 -8

Aucun fichier ne correspond à votre recherche

+15
Voir le fichier
@@ -176,6 +176,13 @@ final class Cablage {
void teleporter(double x, double y, double z, float yaw, float pitch);
void deconnecter(String message);
void journal(String ligne);
/**
* 0.5 (P1.2) : position au sol juste SOUS le joueur (même x, z ; y du premier bloc solide en dessous, au plus
* 64 blocs), {x, y, z, yaw, pitch}, ou null si rien trouvé ou place insuffisante. Jamais de déplacement
* horizontal : le setback de secours ne peut pas servir à se téléporter.
*/
default double[] solSous() { return null; }
}
/**
@@ -202,12 +209,20 @@ final class Cablage {
p.deconnecter("Expulsé par l'anti-triche (" + raison + ").");
} else if (s == Sanction.SETBACK) {
Suivi sv = moteur.suivi(p.id());
double[] sol;
if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) {
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
p.teleporter(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.id(), p.tick() * 50L);
p.journal(p.nom() + " SETBACK (" + raison + ")");
} else if (!sv.aPositionValide() && moteur.config().setbackSolSiPasDePosition && (sol = p.solSous()) != null) {
// 0.5 (P1.2) : reconnexion en l'air (aucune position au sol connue) : retour au sol sous le joueur.
p.annoncerTeleport(GraceTeleport.Origine.SETBACK);
p.teleporter(sol[0], sol[1], sol[2], (float) sol[3], (float) sol[4]);
moteur.apresSetback(p.id(), p.tick() * 50L);
p.journal(String.format(java.util.Locale.ROOT, "%s SETBACK au sol (%s) : pas de position de retour, y=%.2f",
p.nom(), raison, sol[1]));
} else {
// 0.5 (P1.1) : avant, rien n'était fait ni écrit (reconnexion en l'air) et le VL montait jusqu'à
// l'expulsion sans trace du setback raté.
+45
Voir le fichier
@@ -60,6 +60,8 @@ public final class Garde {
/** Marques propres à un joueur, côté adaptateur (ticks du serveur). */
private static final class Marques {
int teleportTick = Integer.MIN_VALUE;
/** 0.5 (P1.2) : jusqu'à ce tick, grâce de connexion. */
int connexionJusquaTick = Integer.MIN_VALUE;
/** 0.4.0 : jusqu'à ce tick, une fusée a propulsé le joueur (plané non contrôlé). */
int propulsionJusquaTick = Integer.MIN_VALUE;
int reculTick = Integer.MIN_VALUE;
@@ -208,6 +210,18 @@ public final class Garde {
m.oeilDernier = null;
}
/** 0.5 (P1.2) : connexion : grâce de connexion (plus longue après une expulsion récente), en plus de la téléportation. */
public static void noterConnexion(ServerPlayer p) {
if (!surThreadServeur(p)) return;
noterTeleport(p);
int tick = p.server.getTickCount();
int grace = MOTEUR.graceConnexionTicks(p.getUUID(), tick * 50L);
marques(p.getUUID()).connexionJusquaTick = tick + grace;
if (grace > CONFIG.graceConnexionTicks) {
ecrireJournal(p.getGameProfile().getName() + " reconnexion apres expulsion recente : grace de " + grace + " ticks");
}
}
/** Le prochain teleport() de ce joueur a cette origine (appelé par le mixin juste avant l'appel). */
public static void annoncerTeleport(ServerPlayer p, GraceTeleport.Origine origine) {
if (!surThreadServeur(p)) return;
@@ -453,6 +467,7 @@ public final class Garde {
.tps(tpsEstime)
.pingMs(p.connection.latency())
.propulsionRecente(tick <= m.propulsionJusquaTick)
.connexionRecente(tick <= m.connexionJusquaTick)
.build();
}
@@ -981,6 +996,35 @@ public final class Garde {
return sous.getBlock().getFriction() != 0.6F || sous.getBlock().getSpeedFactor() != 1.0F;
}
/** Profondeur maximale (blocs) de la recherche du sol sous le joueur (setback de secours, P1.2). */
private static final int SOL_SOUS_MAX_BLOCS = 64;
/**
* 0.5 (P1.2) : sol juste sous le joueur, même x et z : premier bloc à forme de collision non vide (ou fluide) en
* descendant, au plus 64 blocs, avec la place pour la boîte du joueur. Null sinon (vide, hors du monde).
*/
static double[] solSous(ServerPlayer p) {
net.minecraft.world.level.Level l = p.level();
BlockPos.MutableBlockPos q = p.blockPosition().mutable();
for (int i = 0; i <= SOL_SOUS_MAX_BLOCS && q.getY() >= l.getMinBuildHeight(); i++, q.move(0, -1, 0)) {
if (!l.hasChunkAt(q)) return null;
BlockState s = l.getBlockState(q);
double y;
if (!l.getFluidState(q).isEmpty()) {
y = q.getY(); // eau / lave : dans le fluide, la chute s'arrête ou ralentit
} else {
net.minecraft.world.phys.shapes.VoxelShape forme = s.getCollisionShape(l, q);
if (forme.isEmpty()) continue;
y = q.getY() + forme.max(net.minecraft.core.Direction.Axis.Y);
}
if (y > p.getY() + 1e-6) return null; // jamais vers le haut
net.minecraft.world.phys.AABB b = p.getBoundingBox().move(0, y - p.getY(), 0);
if (!l.noCollision(p, b)) return null;
return new double[] {p.getX(), y, p.getZ(), p.getYRot(), p.getXRot()};
}
return null;
}
public static void appliquerSanctionMouvement(ServerPlayer p, Sanction s, List<Verdict> verdicts) {
Cablage.appliquerSanction(MOTEUR, joueur(p), s, verdicts);
}
@@ -998,6 +1042,7 @@ public final class Garde {
}
@Override public void deconnecter(String message) { p.connection.disconnect(Component.literal(message)); }
@Override public void journal(String ligne) { ecrireJournal(ligne); }
@Override public double[] solSous() { return Garde.solSous(p); }
};
}
}
+1 -1
Voir le fichier
@@ -171,7 +171,7 @@ public final class GardeEvents {
public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) {
if (event.getEntity() instanceof ServerPlayer p) {
Garde.moteur().oublierExpulsion(p.getUUID()); // C4 : la marque d'expulsion vaut jusqu'à la reconnexion
Garde.noterTeleport(p);
Garde.noterConnexion(p); // téléportation + 0.5 (P1.2) grâce de connexion
}
}
+15 -1
Voir le fichier
@@ -22,7 +22,8 @@ public final class GardeSpec {
private static final ModConfigSpec.DoubleValue SEUIL_EXPULSION;
private static final ModConfigSpec.EnumValue<Sanction> SANCTION_MAX;
private static final ModConfigSpec.BooleanValue JOURNAL_TOUJOURS;
private static final ModConfigSpec.BooleanValue JOURNAL_TOUJOURS, SETBACK_SOL;
private static final ModConfigSpec.IntValue GRACE_CONNEXION, GRACE_APRES_EXPULSION;
private static final ModConfigSpec.IntValue JOURNAL_LIMITE;
private static final ModConfigSpec.DoubleValue ANGLE_MAX;
@@ -246,6 +247,16 @@ public final class GardeSpec {
.define("combatMesureEnVehicule", false);
b.pop();
b.comment("0.5 : grâces à la connexion (reconnexion en l'air, expulsion récente).").push("graces");
GRACE_CONNEXION = b.comment("Ticks sans contrôle de mouvement ni timer après la connexion (la téléportation de connexion en donne déjà graceTeleportTicks).")
.defineInRange("graceConnexionTicks", 100, 0, 1200);
GRACE_APRES_EXPULSION = b.comment("Idem si le joueur a été expulsé il y a moins de 10 minutes.")
.defineInRange("graceApresExpulsionTicks", 200, 0, 2400);
SETBACK_SOL = b.comment("Sans position de retour valide (reconnexion en l'air), le SETBACK ramène au sol juste sous le joueur.",
"Jamais de déplacement horizontal. false = ancien comportement (setback impossible, seulement journalisé).")
.define("setbackSolSiPasDePosition", true);
b.pop();
b.push("exemptions");
GRACE_TELEPORT = b.defineInRange("graceTeleportTicks", 40, 0, 600);
GRACE_RECUL = b.defineInRange("graceReculTicks", 20, 0, 600);
@@ -390,6 +401,9 @@ public final class GardeSpec {
c.serieFenetreMs = SERIE_FENETRE_MS.get();
c.seriePoints = SERIE_POINTS.get();
c.graceTeleportTicks = GRACE_TELEPORT.get();
c.graceConnexionTicks = GRACE_CONNEXION.get();
c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
c.setbackSolSiPasDePosition = SETBACK_SOL.get();
c.graceReculTicks = GRACE_RECUL.get();
c.graceGelTicks = GRACE_GEL.get();
c.tpsLag = TPS_LAG.get();
+7 -2
Voir le fichier
@@ -21,7 +21,8 @@ public record EtatJoueur(
int ticksDepuisGel,
double tps,
int pingMs,
boolean propulsionRecente) {
boolean propulsionRecente,
boolean connexionRecente) {
public static final int JAMAIS = Integer.MAX_VALUE;
@@ -41,6 +42,7 @@ public record EtatJoueur(
private double tps = 20.0;
private int pingMs = 30;
private boolean propulsionRecente;
private boolean connexionRecente;
public Builder creatif(boolean v) { creatif = v; return this; }
public Builder spectateur(boolean v) { spectateur = v; return this; }
@@ -62,10 +64,13 @@ public record EtatJoueur(
/** 0.4.0 : fusée de feu d'artifice (ou autre poussée connue du serveur) récente : plané non contrôlé. */
public Builder propulsionRecente(boolean v) { propulsionRecente = v; return this; }
/** 0.5 (P1.2) : connexion récente (graceConnexionTicks, plus long après une expulsion récente). */
public Builder connexionRecente(boolean v) { connexionRecente = v; return this; }
public EtatJoueur build() {
return new EtatJoueur(creatif, spectateur, peutVoler, riptide, elytres, levitation, chuteLente,
enVehicule, pocheContraption, utiliseObjet, elytresDeploiementSuspect, ticksDepuisTeleport, ticksDepuisRecul,
ticksDepuisGel, tps, pingMs, propulsionRecente);
ticksDepuisGel, tps, pingMs, propulsionRecente, connexionRecente);
}
}
}
+4
Voir le fichier
@@ -44,6 +44,8 @@ public final class Exemptions {
if (e.pocheContraption()) raisons.add("contraption");
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul");
// 0.5 (P1.2) : reconnexion (souvent en l'air, sans position de retour) : grâce plus longue.
if (e.connexionRecente()) raisons.add("connexion");
}
case VEHICULE -> {
// F20 : le véhicule piloté. Pas d'exemption « véhicule » ici, évidemment.
@@ -51,9 +53,11 @@ public final class Exemptions {
if (e.pocheContraption()) raisons.add("contraption");
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
if (e.ticksDepuisRecul() <= cfg.graceReculTicks) raisons.add("recul");
if (e.connexionRecente()) raisons.add("connexion");
}
case TIMER -> {
if (e.ticksDepuisTeleport() <= cfg.graceTeleportTicks) raisons.add("teleportation");
if (e.connexionRecente()) raisons.add("connexion"); // rafale de paquets du chargement
if (e.ticksDepuisGel() <= cfg.graceGelTicks) raisons.add("gel-serveur");
}
}
+5
Voir le fichier
@@ -164,6 +164,11 @@ public final class GardeConfig {
// --- Exemptions ---
public int graceTeleportTicks = 40;
/** 0.5 (P1.2) : grâce de mouvement / timer après la connexion (ticks) ; plus longue après une expulsion récente. */
public int graceConnexionTicks = 100;
public int graceApresExpulsionTicks = 200;
/** 0.5 (P1.2) : sans position de retour valide, le SETBACK ramène au sol juste sous le joueur (jamais à côté). */
public boolean setbackSolSiPasDePosition = true;
public int graceReculTicks = 20;
public int graceGelTicks = 100;
public double tpsLag = 18.0;
+20 -2
Voir le fichier
@@ -431,7 +431,7 @@ public final class Moteur {
*/
static boolean sortieDEtat(List<String> raisons) {
for (String r : raisons) {
if (!r.equals("teleportation") && !r.equals("recul")) return true;
if (!r.equals("teleportation") && !r.equals("recul") && !r.equals("connexion")) return true;
}
return false;
}
@@ -566,7 +566,25 @@ public final class Moteur {
* jusqu'à sa reconnexion ({@link #oublierExpulsion}). La marque survit à {@link #retirer} (C6).
*/
public boolean expulser(UUID joueur, long nowMs) {
return expulses.add(joueur);
boolean premiere = expulses.add(joueur);
if (premiere) derniereExpulsionMs.put(joueur, nowMs);
return premiere;
}
/** 0.5 (P1.2) : une expulsion compte comme « récente » pour la grâce de reconnexion pendant cette durée. */
public static final long EXPULSION_RECENTE_MS = 10 * 60_000L;
/** Instant (ms, horloge des ticks) de la dernière expulsion de chaque joueur ; survit à la reconnexion. */
private final Map<UUID, Long> derniereExpulsionMs = new HashMap<>();
/**
* 0.5 (P1.2) : durée de la grâce de connexion (ticks) : {@code graceApresExpulsionTicks} si le joueur a été
* expulsé il y a moins de {@link #EXPULSION_RECENTE_MS}, sinon {@code graceConnexionTicks}.
*/
public int graceConnexionTicks(UUID joueur, long nowMs) {
derniereExpulsionMs.values().removeIf(t -> nowMs - t > EXPULSION_RECENTE_MS || nowMs < t);
Long t = derniereExpulsionMs.get(joueur);
int base = Math.max(0, cfg.graceConnexionTicks);
return t != null ? Math.max(base, cfg.graceApresExpulsionTicks) : base;
}
public boolean estExpulse(UUID joueur) {
+2 -2
Voir le fichier
@@ -26,11 +26,11 @@ import org.junit.jupiter.api.Test;
*/
class CablageTest {
private static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
static final UUID ID = UUID.fromString("00000000-0000-0000-0000-000000000042");
private static final String MONDE = "minecraft:overworld";
/** Doublure de ServerPlayer : enregistre ce que la sanction lui fait, dans l'ordre. */
static final class FauxJoueur implements Cablage.Joueur {
static class FauxJoueur implements Cablage.Joueur {
final List<String> actions = new ArrayList<>();
String dimension = MONDE;
int tick = 1000;
+112
Voir le fichier
@@ -0,0 +1,112 @@
package com.gastinelgarde;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.gastinelgarde.core.Controle;
import com.gastinelgarde.core.EtatJoueur;
import com.gastinelgarde.core.EtatMouvement;
import com.gastinelgarde.core.Exemptions;
import com.gastinelgarde.core.GardeConfig;
import com.gastinelgarde.core.Mode;
import com.gastinelgarde.core.Moteur;
import com.gastinelgarde.core.Sanction;
import com.gastinelgarde.core.Verdict;
import java.util.List;
import java.util.UUID;
import org.junit.jupiter.api.Test;
/** 0.5, P1.2 : grâce de connexion, plus longue après une expulsion récente ; setback au sol sans position. */
class ReconnexionP1Test {
private static Verdict verdict(Controle c, Sanction s) {
return new Verdict(c, Mode.ENFORCE, 1, 15, s, s, false, "", List.of());
}
@Test
void dureeDeLaGraceSelonLExpulsionRecente() {
Moteur m = new Moteur(new GardeConfig());
UUID id = UUID.randomUUID();
assertEquals(100, m.graceConnexionTicks(id, 0));
assertTrue(m.expulser(id, 1_000));
m.oublierExpulsion(id); // reconnexion
assertEquals(200, m.graceConnexionTicks(id, 2_000), "expulsé il y a 1 s");
assertEquals(200, m.graceConnexionTicks(id, 1_000 + Moteur.EXPULSION_RECENTE_MS));
assertEquals(100, m.graceConnexionTicks(id, 2_000 + Moteur.EXPULSION_RECENTE_MS), "plus de 10 min après");
}
@Test
void connexionRecenteExempteMouvementVehiculeEtTimerPasLeCombat() {
GardeConfig cfg = new GardeConfig();
EtatJoueur e = EtatJoueur.builder().connexionRecente(true).build();
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.MOUVEMENT).raisons().contains("connexion"));
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.VEHICULE).raisons().contains("connexion"));
assertTrue(Exemptions.evaluer(e, cfg, Exemptions.Famille.TIMER).raisons().contains("connexion"));
assertTrue(!Exemptions.evaluer(e, cfg, Exemptions.Famille.COMBAT).exempt(), "le combat reste mesuré");
}
@Test
void suiviNeufEnLAirPasDExpulsionPendantLaGrace() {
GardeConfig cfg = new GardeConfig();
cfg.mode(Controle.VOL, Mode.ENFORCE);
Moteur m = new Moteur(cfg);
UUID id = UUID.randomUUID();
EtatJoueur enGrace = EtatJoueur.builder().connexionRecente(true).build();
// Flottement immobile en l'air (dy = 0) pendant 100 ticks : en vrai, vol ; ici, grâce de connexion.
for (int t = 0; t < 100; t++) {
EtatMouvement em = new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, false, false);
assertTrue(m.mouvement(id, t * 50L, enGrace, em).isEmpty(), "tick " + t);
}
// Après la grâce, le contrôle reprend (référence remise à zéro, puis infraction).
boolean vu = false;
for (int t = 100; t < 400 && !vu; t++) {
EtatMouvement em = new EtatMouvement(0, 0, 1, false, false, false, false, false, 0, 0, false, false);
vu = !m.mouvement(id, t * 50L, EtatJoueur.normal(), em).isEmpty();
}
assertTrue(vu, "le vol est de nouveau contrôlé après la grâce");
}
/** Doublure qui trouve le sol 12 blocs plus bas. */
static final class JoueurAuDessusDuSol extends CablageTest.FauxJoueur {
double[] sol = {10.5, 52.0, -3.5, 90, 0};
@Override public double[] solSous() { return sol; }
}
@Test
void setbackAuSolSansPositionDeRetour() {
Moteur moteur = new Moteur(new GardeConfig());
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals("annonce SETBACK", p.actions.get(0));
assertEquals("teleport 10.5 52.0 -3.5 90 0", p.actions.get(1));
assertEquals("journal Tricheur SETBACK au sol (vol) : pas de position de retour, y=52.00", p.actions.get(2));
assertEquals(0.0, moteur.suivi(p.id()).vl.valeur(Controle.VOL, p.tick() * 50L), 1e-9, "VL de vol remis à zéro");
}
@Test
void setbackAuSolDesactiveOuSolIntrouvable() {
GardeConfig cfg = new GardeConfig();
cfg.setbackSolSiPasDePosition = false;
Moteur moteur = new Moteur(cfg);
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(0, p.compte("teleport"));
assertEquals(1, p.compte("journal Tricheur SETBACK impossible"));
Moteur m2 = new Moteur(new GardeConfig());
JoueurAuDessusDuSol vide = new JoueurAuDessusDuSol();
vide.sol = null; // vide sous le joueur
Cablage.appliquerSanction(m2, vide, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(0, vide.compte("teleport"));
assertEquals(1, vide.compte("journal Tricheur SETBACK impossible"));
}
@Test
void autreDimensionJamaisDeSetbackAuSol() {
Moteur moteur = new Moteur(new GardeConfig());
moteur.suivi(CablageTest.ID).memoriserPosition(0, 70, 0, 0, 0, "minecraft:the_nether");
JoueurAuDessusDuSol p = new JoueurAuDessusDuSol();
Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK)));
assertEquals(0, p.compte("teleport"), "une position existe (autre dimension) : pas de secours au sol");
}
}