From f744e151080590deba49688095b0d112e9245ba3 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Wed, 14 Oct 2026 08:34:44 +0200 Subject: [PATCH] F05 : la grace de teleportation n'est plus declenchable par le client Refus vanilla de handleMovePlayer, renvois et setback du mod n'ouvrent plus la grace (core/GraceTeleport, injections avant teleport(DDDFF)V). 106 tests. Co-Authored-By: Claude Opus 5.5 --- audit/CORRECTIONS.md | 7 +++- src/main/java/com/gastinelgarde/Garde.java | 25 +++++++++++- .../com/gastinelgarde/core/GraceTeleport.java | 38 ++++++++++++++++++ .../gastinelgarde/mixin/MovePacketMixin.java | 25 +++++++++++- .../gastinelgarde/core/AuditFaillesTest.java | 39 +++++++++++++++++++ 5 files changed, 130 insertions(+), 4 deletions(-) create mode 100644 src/main/java/com/gastinelgarde/core/GraceTeleport.java diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index 1675ab6..d94eaa8 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -10,7 +10,7 @@ Base avant corrections : 98 tests verts. |---|---|---|---|---| | F01 thread réseau | corrigée | voir `git log --grep F01` | `MixinsThreadTest` (2, rouges avant), `AuditFaillesTest.F01_*` ; 101 verts | essai en jeu n° 1 (aucune ligne `timer` en marchant) | | F04 riptide tenu | corrigée | `git log --grep F04` | `AuditFaillesTest.F04_*` (3) ; 104 verts | essai en jeu n° 2 ; retirer le mixin de GastinelClaims 1.1.6 (sinon F04 reste ouverte) ; seuil de 100 blocs/paquet pendant la vrille gardé [À VÉRIFIER] | -| F05 grâce téléportation | à faire | | | | +| F05 grâce téléportation | corrigée | `git log --grep F05` | `AuditFaillesTest.F05_*` (2) ; 106 verts | essai en jeu : `/tp`, perle, TPA, portail sans fausse alerte | | F06 grâce dégâts | à faire | | | | | F07 ping | à faire | | | | | F08 vol aveugle | à faire | | | | @@ -35,3 +35,8 @@ Base avant corrections : 98 tests verts. - `RiptideMoveMixin` et `Garde.etat` passent par le même suivi (`Garde.seuilMouvementVanilla`, `Garde.riptideRecent`) ; le champ `@Unique` du mixin est supprimé. - Reste ouvert : sous la pluie, charger 10 ticks puis relâcher en boucle garde la tolérance ouverte (identique à un enchaînement honnête de riptides, indiscernable sans modèle de trajectoire). Le seuil de 10 000 (100 blocs/paquet) pendant la vrille est gardé : 60 ne suffisait pas le 13/10 (sauts de 63 et 66 blocs). [À VÉRIFIER] avec les traces avant de le baisser. - **Déploiement** : GastinelClaims 1.1.6 contient l'ancien mixin (trident en main) ; tant qu'il est chargé, le seuil vanilla reste relevé dès que le trident est tenu. Le mod GastinelGarde, lui, n'exempte plus le mouvement. + +### F05 +- Nouveau `core/GraceTeleport` : origine de chaque `teleport()`. Le mixin annonce `REFUS_VANILLA` avant les 3 `teleport(DDDFF)V` de `handleMovePlayer` (lit, « moved too quickly », « moved wrongly » ; javap : offsets 360, 606, 1322) et `RENVOI` avant celui de `updateAwaitingTeleport` ; `Garde.appliquerSanctionMouvement` annonce `SETBACK`. Seule l'origine `EXTERNE` (sans annonce : commande, perle, TPA, autre mod) ouvre la grâce ; un renvoi garde l'origine précédente. Connexion, dimension, réapparition : grâce comme avant (événements). +- Après toute téléportation, le mouvement suivant n'est plus comparé à la position d'avant (`mouvementTick` remis à zéro), d'où plus besoin de grâce pour le refus ou le setback. +- Le timer garde la grâce des téléportations externes seulement. diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index d8c062b..1db0d80 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -4,6 +4,7 @@ import com.gastinelgarde.core.Controle; import com.gastinelgarde.core.EtatJoueur; import com.gastinelgarde.core.EtatMouvement; import com.gastinelgarde.core.GardeConfig; +import com.gastinelgarde.core.GraceTeleport; import com.gastinelgarde.core.Mode; import com.gastinelgarde.core.Moteur; import com.gastinelgarde.core.RiptideSuivi; @@ -58,6 +59,7 @@ public final class Garde { int dernierVerdictTick = Integer.MIN_VALUE; int dernierTraceTick = Integer.MIN_VALUE; final RiptideSuivi riptide = new RiptideSuivi(); + final GraceTeleport graceTeleport = new GraceTeleport(); long exemptJusquaMs = 0; double dernierX, dernierY, dernierZ; boolean aDernierePosition; @@ -148,9 +150,29 @@ public final class Garde { // --- Faits collectés --- + /** Connexion, changement de dimension, réapparition : toujours une grâce. */ public static void noterTeleport(ServerPlayer p) { if (!surThreadServeur(p)) return; - marques(p.getUUID()).teleportTick = p.server.getTickCount(); + Marques m = marques(p.getUUID()); + m.teleportTick = p.server.getTickCount(); + m.mouvementTick = Integer.MIN_VALUE; + } + + /** 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; + marques(p.getUUID()).graceTeleport.annoncer(origine); + } + + /** + * Tout teleport() du joueur (mixin) : la grâce ne s'ouvre que pour une origine externe (F05). Le mouvement + * suivant n'est jamais comparé à la position d'avant la téléportation. + */ + public static void teleportVanilla(ServerPlayer p) { + if (!surThreadServeur(p)) return; + Marques m = marques(p.getUUID()); + if (m.graceTeleport.teleport()) m.teleportTick = p.server.getTickCount(); + m.mouvementTick = Integer.MIN_VALUE; } public static void noterRecul(ServerPlayer p) { @@ -462,6 +484,7 @@ public final class Garde { Suivi sv = MOTEUR.suivi(p.getUUID()); String dim = p.level().dimension().location().toString(); 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()); ecrireJournal(p.getGameProfile().getName() + " SETBACK (" + raison + ")"); } diff --git a/src/main/java/com/gastinelgarde/core/GraceTeleport.java b/src/main/java/com/gastinelgarde/core/GraceTeleport.java new file mode 100644 index 0000000..6a9ea33 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/GraceTeleport.java @@ -0,0 +1,38 @@ +package com.gastinelgarde.core; + +/** + * Quelles téléportations ouvrent la grâce de mouvement (F05). Avant, tout {@code teleport()} l'ouvrait, y compris + * le refus vanilla « moved too quickly » qu'un client provoque à volonté : 2 s d'exemption rechargées en boucle. + * + * L'adaptateur annonce l'origine juste avant l'appel ({@link #annoncer}), puis la marque de téléportation + * demande {@link #teleport()}. Sans annonce, l'origine est externe (commande, perle, mod, dimension). + */ +public final class GraceTeleport { + + public enum Origine { + /** /tp, perle, TPA, autre mod : la position change sans que le client l'ait demandé. */ + EXTERNE, + /** handleMovePlayer refuse le paquet (trop rapide, déplacement impossible, lit) : provocable par le client. */ + REFUS_VANILLA, + /** Retour en arrière décidé par GastinelGarde. */ + SETBACK, + /** Renvoi d'une téléportation non confirmée (updateAwaitingTeleport) : même origine que la précédente. */ + RENVOI + } + + private Origine annoncee = Origine.EXTERNE; + private boolean derniereExterne; + + public void annoncer(Origine o) { + annoncee = o == null ? Origine.EXTERNE : o; + } + + /** Une téléportation a lieu : vrai si elle ouvre la grâce. Consomme l'annonce. */ + public boolean teleport() { + Origine o = annoncee; + annoncee = Origine.EXTERNE; + if (o == Origine.RENVOI) return derniereExterne; + derniereExterne = o == Origine.EXTERNE; + return derniereExterne; + } +} diff --git a/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java b/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java index a789879..2104345 100644 --- a/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java +++ b/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java @@ -1,6 +1,7 @@ package com.gastinelgarde.mixin; import com.gastinelgarde.Garde; +import com.gastinelgarde.core.GraceTeleport; import net.minecraft.server.level.ServerPlayer; import net.minecraft.server.network.ServerGamePacketListenerImpl; import org.spongepowered.asm.mixin.Mixin; @@ -9,6 +10,7 @@ import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.ModifyArg; import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; /** * Observe les paquets de mouvement et les téléportations. Aucune modification du comportement vanilla : on @@ -52,10 +54,29 @@ public abstract class MovePacketMixin { return player != null ? Garde.auSolPourChute(player, auSolClient) : auSolClient; } - // Toute téléportation (commande, mod, perle, setback) passe par cette méthode : on marque le joueur. + // Toute téléportation (commande, mod, perle, setback, refus vanilla) passe par cette méthode. La grâce ne + // s'ouvre que si l'origine est externe (F05) : les appels ci-dessous annoncent les autres origines. @Inject(method = "teleport(DDDFFLjava/util/Set;)V", at = @At("HEAD")) private void gastinelgarde$marqueTeleport(double x, double y, double z, float yaw, float pitch, java.util.Set relatifs, CallbackInfo ci) { - if (player != null) Garde.noterTeleport(player); + if (player != null) Garde.teleportVanilla(player); + } + + // Les 3 teleport() de handleMovePlayer (lit, « moved too quickly », « moved wrongly ») : refus d'un paquet, + // provocables par le client. Vérifié par javap sur NeoForge 21.1.234 (offsets 360, 606, 1322). + @Inject(method = "handleMovePlayer", + at = @At(value = "INVOKE", + target = "Lnet/minecraft/server/network/ServerGamePacketListenerImpl;teleport(DDDFF)V")) + private void gastinelgarde$refusVanilla(net.minecraft.network.protocol.game.ServerboundMovePlayerPacket packet, + CallbackInfo ci) { + if (player != null) Garde.annoncerTeleport(player, GraceTeleport.Origine.REFUS_VANILLA); + } + + // Renvoi d'une téléportation non confirmée au bout d'une seconde : garde l'origine de la précédente. + @Inject(method = "updateAwaitingTeleport", + at = @At(value = "INVOKE", + target = "Lnet/minecraft/server/network/ServerGamePacketListenerImpl;teleport(DDDFF)V")) + private void gastinelgarde$renvoi(CallbackInfoReturnable cir) { + if (player != null) Garde.annoncerTeleport(player, GraceTeleport.Origine.RENVOI); } } diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index 7ff0661..d866515 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -89,4 +89,43 @@ class AuditFaillesTest { assertTrue(r.actif(100 + RiptideTolerance.GRACE_TICKS)); assertFalse(r.actif(101 + RiptideTolerance.GRACE_TICKS)); } + + // ---------------------------------------------------------------- F05 + /** + * Avant : un paquet volontairement trop rapide toutes les 1,5 s faisait téléporter le joueur par vanilla, et + * chaque teleport() rouvrait 2 s de grâce. Maintenant, le refus vanilla (et le setback) n'ouvrent rien. + */ + @Test + void F05_refus_vanilla_provoque_n_ouvre_plus_la_grace() { + GraceTeleport g = new GraceTeleport(); + int teleportTick = Integer.MIN_VALUE; + long now = 0; + boolean vu = false; + for (int tick = 0; tick < 600; tick++) { + if (tick % 30 == 0) { // le client provoque « moved too quickly » + g.annoncer(GraceTeleport.Origine.REFUS_VANILLA); + if (g.teleport()) teleportTick = tick; + } + int depuis = teleportTick == Integer.MIN_VALUE ? EtatJoueur.JAMAIS : tick - teleportTick; + EtatJoueur etat = EtatJoueur.builder().ticksDepuisTeleport(depuis).build(); + if (!moteur.mouvement(j, now, etat, mv(1.0, 0, 1, true, true)).isEmpty()) vu = true; + now += 50; + } + assertTrue(vu, "20 blocs/s soutenus : vu malgré les refus vanilla provoqués"); + } + + @Test + void F05_origines_de_teleportation() { + GraceTeleport g = new GraceTeleport(); + assertTrue(g.teleport(), "sans annonce : /tp, perle, autre mod"); + g.annoncer(GraceTeleport.Origine.SETBACK); + assertFalse(g.teleport(), "setback du mod"); + g.annoncer(GraceTeleport.Origine.RENVOI); + assertFalse(g.teleport(), "renvoi d'un setback non confirmé"); + assertTrue(g.teleport(), "l'annonce est consommée"); + g.annoncer(GraceTeleport.Origine.RENVOI); + assertTrue(g.teleport(), "renvoi d'une téléportation externe : grâce gardée (client lent)"); + g.annoncer(GraceTeleport.Origine.REFUS_VANILLA); + assertFalse(g.teleport()); + } }