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 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Opus 5.5 a révisé 2026-10-14 08:32:44 +02:00
1 Parent f69348b08b
révision f151ab5a5d
6 fichiers modifiés
+166 -44

Aucun fichier ne correspond à votre recherche

+38 -5
Voir le fichier
@@ -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) {
+9
Voir le fichier
@@ -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);
+60
Voir le fichier
@@ -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));
}
}
+12 -38
Voir le fichier
@@ -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<Integer> 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));
}
}
+40
Voir le fichier
@@ -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));
}
}