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 à :
1 Parent
f69348b08b
révision
f151ab5a5d
6 fichiers modifiés
+166
-44
Aucun fichier ne correspond à votre recherche
@@ -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) {
|
||||
|
||||
@@ -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);
|
||||
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
@@ -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));
|
||||
}
|
||||
}
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur