From f151ab5a5d93eeb59fabecca9e1c4d37d4366a39 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Wed, 14 Oct 2026 08:32:44 +0200 Subject: [PATCH] F04 : riptide seulement pendant la vrille ou 2 s apres le relachement du trident Tenir un trident Impulsion ne releve plus le seuil vanilla ni n'exempte le mouvement. Nouveau core/RiptideSuivi, evenement LivingEntityUseItemEvent.Stop, 104 tests. Co-Authored-By: Claude Opus 5.5 --- audit/CORRECTIONS.md | 8 ++- src/main/java/com/gastinelgarde/Garde.java | 43 +++++++++++-- .../java/com/gastinelgarde/GardeEvents.java | 9 +++ .../com/gastinelgarde/core/RiptideSuivi.java | 60 +++++++++++++++++++ .../gastinelgarde/mixin/RiptideMoveMixin.java | 50 ++++------------ .../gastinelgarde/core/AuditFaillesTest.java | 40 +++++++++++++ 6 files changed, 166 insertions(+), 44 deletions(-) create mode 100644 src/main/java/com/gastinelgarde/core/RiptideSuivi.java diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index 08545af..1675ab6 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -9,7 +9,7 @@ Base avant corrections : 98 tests verts. | Faille | État | Commit | Tests | Reste à faire | |---|---|---|---|---| | 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 | à faire | | | | +| 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 | | | | | F06 grâce dégâts | à faire | | | | | F07 ping | à faire | | | | @@ -29,3 +29,9 @@ Base avant corrections : 98 tests verts. - Les autres injections dans `handleMovePlayer` (`TAIL`, `@ModifyArg doCheckFallDamage`, `@ModifyConstant 100/300`) sont après l'appel : jamais exécutées sur le thread réseau. `getMaximumFlyingTicks` et `teleport` ne sont pas des `handle*`. - Garde supplémentaire : `Garde.surThreadServeur` (sortie si `!server.isSameThread()`) dans `avantMouvement`, `apresMouvement`, `noterTeleport`, `auSolPourChute`. - Test de règle générale : aucun injecteur sur une méthode `handle*` en `HEAD` (pour les mixins futurs, F20). + +### F04 +- Nouveau `core/RiptideSuivi` : la tolérance riptide (seuil vanilla relevé et exemption de mouvement) ne s'ouvre que si le serveur voit la vrille (`isAutoSpinAttack`) ou si un trident Impulsion est **relâché après au moins 10 ticks de charge** (`LivingEntityUseItemEvent.Stop`, durée mesurée par le serveur), avec de l'eau ou de la pluie (sur le joueur, ou au moins dans la dimension : cas du 13/10 où le serveur juge la pluie autrement que le client). Puis 40 ticks de grâce. Tenir le trident ne fait plus rien. +- `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. diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 34f81d9..d8c062b 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -6,6 +6,7 @@ import com.gastinelgarde.core.EtatMouvement; import com.gastinelgarde.core.GardeConfig; import com.gastinelgarde.core.Mode; import com.gastinelgarde.core.Moteur; +import com.gastinelgarde.core.RiptideSuivi; import com.gastinelgarde.core.Sanction; import com.gastinelgarde.core.Suivi; import com.gastinelgarde.core.TraceFichier; @@ -56,7 +57,7 @@ public final class Garde { int reculTick = Integer.MIN_VALUE; int dernierVerdictTick = Integer.MIN_VALUE; int dernierTraceTick = Integer.MIN_VALUE; - int dernierRiptideTick = Integer.MIN_VALUE; + final RiptideSuivi riptide = new RiptideSuivi(); long exemptJusquaMs = 0; double dernierX, dernierY, dernierZ; boolean aDernierePosition; @@ -196,10 +197,9 @@ public final class Garde { int tick = p.server.getTickCount(); Marques m = marques(p.getUUID()); - boolean riptide = p.isAutoSpinAttack() || tridentImpulsion(p.getMainHandItem(), p) || tridentImpulsion(p.getOffhandItem(), p); - if (riptide) m.dernierRiptideTick = tick; - boolean riptideRecent = m.dernierRiptideTick != Integer.MIN_VALUE - && tick - m.dernierRiptideTick <= com.gastinelgarde.core.RiptideTolerance.GRACE_TICKS; + // F04 : tenir un trident Impulsion n'exempte plus ; seulement la vrille ou un relâchement valide, et 2 s après. + m.riptide.observer(tick, p.isAutoSpinAttack()); + boolean riptideRecent = m.riptide.actif(tick); boolean mange = false; if (p.isUsingItem()) { @@ -235,6 +235,39 @@ public final class Garde { return stack.is(Items.TRIDENT) && EnchantmentHelper.getTridentSpinAttackStrength(stack, joueur) > 0.0F; } + /** Un objet vient d'être relâché (événement Stop) : un trident Impulsion chargé ouvre la tolérance riptide. */ + public static void noterRelache(ServerPlayer p, ItemStack stack, int ticksRestants) { + if (!surThreadServeur(p) || !tridentImpulsion(stack, p)) return; + int charge = stack.getUseDuration(p) - ticksRestants; + boolean ouvert = marques(p.getUUID()).riptide.relache(p.server.getTickCount(), true, charge, + p.isInWaterOrRain(), p.level().isRaining()); + if (ouvert) { + GastinelGarde.LOGGER.debug("[GastinelGarde] riptide : relâchement de {} (charge {} ticks)", + p.getGameProfile().getName(), charge); + } + } + + /** Seuil vanilla « moved too quickly » (appelé par RiptideMoveMixin) : relevé seulement pendant un riptide réel. */ + public static float seuilMouvementVanilla(ServerPlayer p, float seuil) { + RiptideSuivi r = marques(p.getUUID()).riptide; + int tick = p.server.getTickCount(); + r.observer(tick, p.isAutoSpinAttack()); + float resultat = r.seuil(seuil, tick, p.isAutoSpinAttack()); + if (resultat != seuil) { + GastinelGarde.LOGGER.debug("[GastinelGarde] riptide : seuil relevé pour {} (vrille={}, depuis={} ticks)", + p.getGameProfile().getName(), p.isAutoSpinAttack(), r.ticksDepuis(tick)); + } + return resultat; + } + + /** Vrille en cours ou dans les 2 s (appelé par RiptideMoveMixin pour le contrôle anti-vol vanilla). */ + public static boolean riptideRecent(ServerPlayer p) { + RiptideSuivi r = marques(p.getUUID()).riptide; + int tick = p.server.getTickCount(); + r.observer(tick, p.isAutoSpinAttack()); + return r.actif(tick); + } + /** La détection est refaite au plus toutes les 10 ticks par joueur. */ private static boolean pocheContraptionEnCache(Player p, Marques m, int tick) { if (m.contraptionTick == Integer.MIN_VALUE || tick - m.contraptionTick >= 10 || tick < m.contraptionTick) { diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index 46ee511..81e1f02 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -13,6 +13,7 @@ import net.minecraft.world.phys.Vec3; import net.neoforged.bus.api.SubscribeEvent; import net.neoforged.neoforge.common.util.FakePlayer; import net.neoforged.neoforge.event.entity.living.LivingDamageEvent; +import net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent; import net.neoforged.neoforge.event.entity.player.AttackEntityEvent; import net.neoforged.neoforge.event.entity.player.PlayerEvent; import net.neoforged.neoforge.event.server.ServerStartingEvent; @@ -79,6 +80,14 @@ public final class GardeEvents { } } + /** F04 : seul un trident Impulsion relâché après charge ouvre la tolérance riptide (pas le trident tenu). */ + @SubscribeEvent + public static void onRelache(LivingEntityUseItemEvent.Stop event) { + if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) { + Garde.noterRelache(p, event.getItem(), event.getDuration()); + } + } + @SubscribeEvent public static void onDegats(LivingDamageEvent.Post event) { if (event.getEntity() instanceof ServerPlayer p) Garde.noterRecul(p); diff --git a/src/main/java/com/gastinelgarde/core/RiptideSuivi.java b/src/main/java/com/gastinelgarde/core/RiptideSuivi.java new file mode 100644 index 0000000..8798abe --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/RiptideSuivi.java @@ -0,0 +1,60 @@ +package com.gastinelgarde.core; + +/** + * Utilisation réelle du riptide par un joueur (F04). Tenir un trident Impulsion ne compte pas : seuls la vrille + * vue par le serveur et le relâchement d'un trident chargé ouvrent la tolérance, pour la vrille et + * {@link RiptideTolerance#GRACE_TICKS} ticks après. + * + * Le relâchement compte même si le serveur ne lance pas la vrille : il juge la pluie à la position du joueur + * (biome, altitude) alors que le client la lance quand même (constaté le 13/10/2026). On exige quand même de + * l'eau ou de la pluie quelque part dans le monde, sinon un client honnête ne peut pas non plus partir en vrille. + */ +public final class RiptideSuivi { + + /** TridentItem.releaseUsing : la vrille part après au moins 10 ticks de charge. */ + public static final int CHARGE_MIN_TICKS = 10; + + private int dernierTick = Integer.MIN_VALUE; + + /** À chaque mouvement : le serveur voit-il le joueur en vrille (isAutoSpinAttack) ? */ + public void observer(int tick, boolean vrilleServeur) { + if (vrilleServeur) dernierTick = tick; + } + + /** + * Un objet vient d'être relâché (LivingEntityUseItemEvent.Stop). + * + * @param tridentImpulsion l'objet est un trident avec Impulsion + * @param ticksCharge durée d'utilisation mesurée par le serveur + * @param eauOuPluie le serveur voit le joueur dans l'eau ou sous la pluie + * @param pluieDansLeMonde il pleut dans cette dimension (le client peut juger la pluie autrement) + * @return vrai si la tolérance est ouverte + */ + public boolean relache(int tick, boolean tridentImpulsion, int ticksCharge, boolean eauOuPluie, boolean pluieDansLeMonde) { + if (!relacheLanceLaVrille(tridentImpulsion, ticksCharge, eauOuPluie, pluieDansLeMonde)) return false; + dernierTick = tick; + return true; + } + + public static boolean relacheLanceLaVrille(boolean tridentImpulsion, int ticksCharge, boolean eauOuPluie, + boolean pluieDansLeMonde) { + return tridentImpulsion && ticksCharge >= CHARGE_MIN_TICKS && (eauOuPluie || pluieDansLeMonde); + } + + /** Ticks depuis la dernière vrille ou le dernier relâchement valide, -1 si jamais. */ + public int ticksDepuis(int tick) { + if (dernierTick == Integer.MIN_VALUE || tick < dernierTick) return -1; + return tick - dernierTick; + } + + /** Vrille en cours ou dans la grâce. */ + public boolean actif(int tick) { + int d = ticksDepuis(tick); + return d >= 0 && d <= RiptideTolerance.GRACE_TICKS; + } + + /** Seuil vanilla « moved too quickly » à utiliser maintenant. */ + public float seuil(float seuilVanilla, int tick, boolean vrilleServeur) { + return RiptideTolerance.seuil(seuilVanilla, vrilleServeur, ticksDepuis(tick)); + } +} diff --git a/src/main/java/com/gastinelgarde/mixin/RiptideMoveMixin.java b/src/main/java/com/gastinelgarde/mixin/RiptideMoveMixin.java index 79a6bb3..5febdf3 100644 --- a/src/main/java/com/gastinelgarde/mixin/RiptideMoveMixin.java +++ b/src/main/java/com/gastinelgarde/mixin/RiptideMoveMixin.java @@ -1,16 +1,11 @@ package com.gastinelgarde.mixin; -import com.gastinelgarde.GastinelGarde; -import com.gastinelgarde.core.RiptideTolerance; +import com.gastinelgarde.Garde; import net.minecraft.server.level.ServerPlayer; import net.minecraft.server.network.ServerGamePacketListenerImpl; import net.minecraft.world.entity.Entity; -import net.minecraft.world.item.ItemStack; -import net.minecraft.world.item.Items; -import net.minecraft.world.item.enchantment.EnchantmentHelper; import org.spongepowered.asm.mixin.Mixin; import org.spongepowered.asm.mixin.Shadow; -import org.spongepowered.asm.mixin.Unique; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Constant; import org.spongepowered.asm.mixin.injection.Inject; @@ -19,48 +14,33 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; /** * Plus de retour en arrière en enchaînant les riptides (repris de GastinelClaims 1.1.6, décision T6) : seuil - * « moved too quickly » relevé quand le joueur tient un trident Impulsion (ou est en vrille), et 2 s après. + * « moved too quickly » relevé pendant une vrille réelle et 2 s après. * - * On ne se fie pas seulement à isAutoSpinAttack() : le serveur ne lance la vrille que s'il juge le joueur sous la + * F04 (audit 2026-10-14) : tenir un trident Impulsion ne relève plus rien. Le riptide compte quand le serveur voit + * la vrille (isAutoSpinAttack) ou quand un trident Impulsion chargé est relâché (événement Stop, voir + * {@link com.gastinelgarde.core.RiptideSuivi}) : le serveur ne lance la vrille que s'il juge le joueur sous la * pluie ou dans l'eau (biome, altitude), alors que le client la lance quand même (constaté le 13/10/2026). * - * ATTENTION au déploiement : GastinelClaims 1.1.6 contient le même mixin. Retirer celui de GastinelClaims - * (1.1.7) avant ou en même temps que de déployer GastinelGarde, sinon le seuil est relevé deux fois (sans - * danger : les deux prennent le maximum, mais le journal de debug est doublé). + * ATTENTION au déploiement : GastinelClaims 1.1.6 contient l'ancien mixin (trident en main). Retirer celui de + * GastinelClaims (1.1.7) avant ou en même temps que de déployer GastinelGarde : sinon le seuil reste relevé dès + * que le trident est en main, et la correction F04 ne sert à rien. */ @Mixin(ServerGamePacketListenerImpl.class) public abstract class RiptideMoveMixin { @Shadow public ServerPlayer player; - @Unique private int gastinelgarde$dernierTickRiptide = Integer.MIN_VALUE; - // 100.0f n'apparaît qu'une fois dans handleMovePlayer (vérifié par javap sur NeoForge 21.1.234) : // c'est le seuil hors élytres du contrôle « moved too quickly ». @ModifyConstant(method = "handleMovePlayer", constant = @Constant(floatValue = 100.0F)) private float gastinelgarde$seuilRiptide(float seuil) { - return gastinelgarde$seuil(seuil); + return Garde.seuilMouvementVanilla(player, seuil); } // 300.0f : même contrôle quand le joueur vole en élytres (riptide + élytres), unique lui aussi dans la méthode. @ModifyConstant(method = "handleMovePlayer", constant = @Constant(floatValue = 300.0F)) private float gastinelgarde$seuilRiptideElytres(float seuil) { - return gastinelgarde$seuil(seuil); - } - - @Unique - private float gastinelgarde$seuil(float seuil) { - boolean riptide = player.isAutoSpinAttack() - || gastinelgarde$tridentImpulsion(player.getMainHandItem(), player) - || gastinelgarde$tridentImpulsion(player.getOffhandItem(), player); - if (riptide) gastinelgarde$dernierTickRiptide = player.tickCount; - int depuis = gastinelgarde$dernierTickRiptide == Integer.MIN_VALUE ? -1 : player.tickCount - gastinelgarde$dernierTickRiptide; - float resultat = RiptideTolerance.seuil(seuil, riptide, depuis); - if (resultat != seuil) { - GastinelGarde.LOGGER.debug("[GastinelGarde] riptide : seuil relevé pour {} (vrille={}, depuis={} ticks)", - player.getGameProfile().getName(), player.isAutoSpinAttack(), depuis); - } - return resultat; + return Garde.seuilMouvementVanilla(player, seuil); } /** @@ -69,13 +49,7 @@ public abstract class RiptideMoveMixin { */ @Inject(method = "getMaximumFlyingTicks", at = @At("RETURN"), cancellable = true) private void gastinelgarde$volApresRiptide(Entity entity, CallbackInfoReturnable cir) { - if (entity != player || gastinelgarde$dernierTickRiptide == Integer.MIN_VALUE) return; - int depuis = player.tickCount - gastinelgarde$dernierTickRiptide; - if (depuis >= 0 && depuis <= RiptideTolerance.GRACE_TICKS) cir.setReturnValue(Math.max(cir.getReturnValue(), 200)); - } - - @Unique - private static boolean gastinelgarde$tridentImpulsion(ItemStack stack, ServerPlayer joueur) { - return stack.is(Items.TRIDENT) && EnchantmentHelper.getTridentSpinAttackStrength(stack, joueur) > 0.0F; + if (entity != player || player == null) return; + if (Garde.riptideRecent(player)) cir.setReturnValue(Math.max(cir.getReturnValue(), 200)); } } diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index 3a30770..7ff0661 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -49,4 +49,44 @@ class AuditFaillesTest { } assertTrue(double_, "20 paquets/s comptés deux fois = 40/s : c'est pourquoi le mixin ne doit compter qu'une fois"); } + + // ---------------------------------------------------------------- F04 + /** + * Avant : le mixin passait riptide=true dès qu'un trident Impulsion était en main, seuil vanilla 100 → 10 000 + * (99 blocs par paquet acceptés) et exemption de tout le mouvement. Maintenant, le trident tenu ne compte pas. + */ + @Test + void F04_trident_tenu_ne_releve_plus_le_seuil_vanilla() { + RiptideSuivi r = new RiptideSuivi(); + double distance = 99.0; // un « TP » de 99 blocs en un paquet + for (int tick = 0; tick < 200; tick++) { + r.observer(tick, false); // trident en main, pas de vrille : le serveur ne voit rien + float seuil = r.seuil(100f, tick, false); + assertEquals(100f, seuil, "trident tenu, tick " + tick); + assertTrue(distance * distance > seuil, "refusé par vanilla (moved too quickly)"); + assertFalse(r.actif(tick), "aucune exemption de mouvement"); + } + } + + @Test + void F04_vrille_serveur_puis_deux_secondes_seulement() { + RiptideSuivi r = new RiptideSuivi(); + for (int tick = 0; tick < 20; tick++) r.observer(tick, true); // vrille de 20 ticks (startAutoSpinAttack(20)) + assertEquals(RiptideTolerance.SEUIL_RIPTIDE, r.seuil(100f, 19, true)); + assertTrue(r.actif(19 + RiptideTolerance.GRACE_TICKS), "élan : 2 s après la fin de la vrille"); + assertFalse(r.actif(20 + RiptideTolerance.GRACE_TICKS), "plus rien après 2 s"); + assertEquals(100f, r.seuil(100f, 20 + RiptideTolerance.GRACE_TICKS, false)); + } + + @Test + void F04_relachement_charge_ouvre_la_tolerance_pas_un_clic() { + RiptideSuivi r = new RiptideSuivi(); + assertFalse(r.relache(0, true, 5, true, true), "charge de 5 ticks : vanilla ne lance pas la vrille"); + assertFalse(r.actif(0)); + assertFalse(r.relache(0, false, 30, true, true), "trident sans Impulsion"); + assertFalse(r.relache(0, true, 30, false, false), "temps sec et hors de l'eau : même un client honnête ne part pas"); + assertTrue(r.relache(100, true, 12, false, true), "pluie dans le monde mais pas sur le joueur (cas du 13/10)"); + assertTrue(r.actif(100 + RiptideTolerance.GRACE_TICKS)); + assertFalse(r.actif(101 + RiptideTolerance.GRACE_TICKS)); + } }