diff --git a/src/main/java/com/gastinelgarde/Cablage.java b/src/main/java/com/gastinelgarde/Cablage.java index c19645b..1ac0d1c 100644 --- a/src/main/java/com/gastinelgarde/Cablage.java +++ b/src/main/java/com/gastinelgarde/Cablage.java @@ -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é. diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index df0f4e0..479a04f 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -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 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); } }; } } diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index b0acc35..23661ed 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -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 } } diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index 5465abf..fae6855 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -22,7 +22,8 @@ public final class GardeSpec { private static final ModConfigSpec.DoubleValue SEUIL_EXPULSION; private static final ModConfigSpec.EnumValue 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(); diff --git a/src/main/java/com/gastinelgarde/core/EtatJoueur.java b/src/main/java/com/gastinelgarde/core/EtatJoueur.java index bdebb4f..1a93571 100644 --- a/src/main/java/com/gastinelgarde/core/EtatJoueur.java +++ b/src/main/java/com/gastinelgarde/core/EtatJoueur.java @@ -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); } } } diff --git a/src/main/java/com/gastinelgarde/core/Exemptions.java b/src/main/java/com/gastinelgarde/core/Exemptions.java index 5ba9a63..d2ffea6 100644 --- a/src/main/java/com/gastinelgarde/core/Exemptions.java +++ b/src/main/java/com/gastinelgarde/core/Exemptions.java @@ -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"); } } diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index e579e44..fa22791 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -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; diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index 005a73f..c6a3389 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -431,7 +431,7 @@ public final class Moteur { */ static boolean sortieDEtat(List 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 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) { diff --git a/src/test/java/com/gastinelgarde/CablageTest.java b/src/test/java/com/gastinelgarde/CablageTest.java index 685b523..8ac064a 100644 --- a/src/test/java/com/gastinelgarde/CablageTest.java +++ b/src/test/java/com/gastinelgarde/CablageTest.java @@ -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 actions = new ArrayList<>(); String dimension = MONDE; int tick = 1000; diff --git a/src/test/java/com/gastinelgarde/ReconnexionP1Test.java b/src/test/java/com/gastinelgarde/ReconnexionP1Test.java new file mode 100644 index 0000000..2b0a9d2 --- /dev/null +++ b/src/test/java/com/gastinelgarde/ReconnexionP1Test.java @@ -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"); + } +}