From 2682d0cb3d538b4362624930957aae41dee5cd2a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Th=C3=A9o=20Gastinel?= <264859180+gastinelt@users.noreply.github.com> Date: Thu, 15 Oct 2026 01:04:52 +0200 Subject: [PATCH] GastinelClaims 1.1.3 a 1.1.6 : tolerance riptide (mixin RiptideMoveMixin, RiptideTolerance) Commit groupe : les etats intermediaires 1.1.3, 1.1.4, 1.1.5 n'ont jamais ete sauvegardes (code modifie en place, seul 1.1.6 existe), donc non reconstituables. Co-Authored-By: Claude Opus 5.5 --- README.md | 23 +++++- gradle.properties | 2 +- .../gastinelclaims/core/RiptideTolerance.java | 25 ++++++ .../mixin/RiptideMoveMixin.java | 77 +++++++++++++++++++ .../resources/META-INF/neoforge.mods.toml | 2 +- src/main/resources/gastinelclaims.mixins.json | 2 +- .../core/RiptideToleranceTest.java | 29 +++++++ 7 files changed, 156 insertions(+), 4 deletions(-) create mode 100644 src/main/java/com/gastinelclaims/core/RiptideTolerance.java create mode 100644 src/main/java/com/gastinelclaims/mixin/RiptideMoveMixin.java create mode 100644 src/test/java/com/gastinelclaims/core/RiptideToleranceTest.java diff --git a/README.md b/README.md index 1ea64d9..25664d6 100644 --- a/README.md +++ b/README.md @@ -8,6 +8,7 @@ Protection de terrains par chunk pour NeoForge 1.21.1 (21.1.234). **Mod côté s - `/unclaim` : libère le chunk courant s'il est à toi. - `/friend`, `/friend add `, `/friend unadd ` : un ami a accès à tous tes claims. Le pseudo doit être connu du serveur (en ligne ou déjà venu). Stocké par UUID. - **Pseudos spéciaux (depuis 1.1.1)** : un pseudo avec un caractère non tapable (ex. `gabybou201"`) se vise sans ce caractère (`/friend add gabybou201`). Ordre : pseudo exact, puis forme normalisée (minuscules, hors `[A-Za-z0-9_]` retiré) parmi les joueurs en ligne, puis `usercache.json`. Un seul compte correspond -> utilisé (UUID du vrai profil, vrai pseudo affiché). Plusieurs -> refus avec la liste des candidats (jamais de choix au hasard). Tab propose la forme sans guillemet. Logique pure : `core/PseudoMatcher.java` (tests `PseudoMatcherTest`). +- **Serveur hors-ligne (depuis 1.1.2)** : dans `usercache.json`, seuls les profils dont l'UUID est l'UUID hors-ligne du pseudo (`OfflinePlayer:`, version 3) sont gardés (`PseudoMatcher.garderHorsLigne`). Les UUID Microsoft venus de la whitelist ou de `ops.json` ne peuvent pas se connecter, et rendaient le pseudo ambigu (« Plusieurs joueurs ressemblent à… »). En `online-mode=true`, rien n'est filtré. ## Config `config/gastinelclaims-server.toml` : `maxClaimsParJoueur = 25`. @@ -24,7 +25,27 @@ Casser/poser des blocs, clic droit sur un bloc (coffres, portes, leviers, bouton - Lave/eau qui coule d'un chunk voisin, flèches/projectiles sur les cadres, dispensers : non bloqués. ## Build (sur cornafserver, pas sur le PC) -Copier le dossier puis `sh build-sur-cornafserver.sh` (conteneur `eclipse-temurin:21-jdk` jetable, cache Gradle dans `~/.cache/gastinelclaims-gradle`). Lance les tests JUnit puis produit `build/libs/gastinelclaims-neoforge-1.21.1-1.1.1.jar`. +Copier le dossier puis `sh build-sur-cornafserver.sh` (conteneur `eclipse-temurin:21-jdk` jetable, cache Gradle dans `~/.cache/gastinelclaims-gradle`). Lance les tests JUnit puis produit `build/libs/gastinelclaims-neoforge-1.21.1-.jar` (version dans `gradle.properties` **et** `META-INF/neoforge.mods.toml`, à changer ensemble). +Le ménage du 13/10/2026 a supprimé l'image `eclipse-temurin:21-jdk` et le cache Gradle : le premier build suivant les retélécharge (environ 4 min au lieu de 15 s). + +## Riptide (depuis 1.1.3, temporaire : à déplacer dans GastinelGarde) +`mixin/RiptideMoveMixin.java` + `core/RiptideTolerance.java` (tests `RiptideToleranceTest`). Corrige les retours en arrière quand on enchaîne les riptides. +- Contrôle vanilla « moved too quickly » (`ServerGamePacketListenerImpl.handleMovePlayer`) : les seuils `100.0f` (marche) et `300.0f` (élytres) passent à **100 blocs par paquet** (10 000 au carré) quand le joueur tient un **trident Impulsion** dans une main ou est en vrille, et pendant 40 ticks (2 s) après. Chaque constante n'apparaît qu'une fois dans la méthode (vérifié par `javap` sur NeoForge 21.1.234). +- On ne se fie pas seulement à `isAutoSpinAttack()` : 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 (journaux du 13/10 : `vrille=false`). +- Contrôle anti-vol (`allow-flight=false`) : `getMaximumFlyingTicks` passe de 80 à 200 ticks (10 s) pendant ces 2 s, pour ne pas expulser un joueur qui plane sur son élan. +- Journal : `[GastinelClaims] riptide : seuil relevé…` au niveau DEBUG (`logs/debug.log`). +- **Limite assumée** : un joueur qui tient un trident Impulsion peut aller jusqu'à 100 blocs par paquet sans être renvoyé en arrière. + +## Historique +| Version | Date | Contenu | +|---|---|---| +| 1.1.6 | 13/10/2026 | seuil riptide 60 → 100 blocs (sauts de 63 et 66 blocs encore refusés) | +| 1.1.5 | 13/10/2026 | seuil élytres (300) aussi relevé ; délai anti-vol après un riptide ; `allow-flight` remis à false sur le serveur | +| 1.1.4 | 13/10/2026 | riptide détecté par le trident Impulsion en main (la vrille n'est pas toujours connue du serveur) | +| 1.1.3 | 13/10/2026 | `RiptideMoveMixin` (seuil 60 blocs pendant la vrille) | +| 1.1.2 | 13/10/2026 | `/friend` : profils Microsoft du cache ignorés en mode hors-ligne | +| 1.1.1 | 11/10/2026 | pseudos avec caractère non tapable, ambiguïté annoncée | +| 1.1.0 | 09/10/2026 | zones protégées (spawn incassable) | ## Zones protégées (depuis 1.1.0) — spawn incassable Module séparé de `/claim` (fichiers `ZonesProtegees.java`, `ZoneEvents.java`, `mixin/`, `core/ZonesConfig.java`). Une zone se cumule avec les claims et passe avant eux (priorité `HIGHEST`) ; `/claim` n'est pas modifié. diff --git a/gradle.properties b/gradle.properties index 743d52c..289ae86 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,7 +1,7 @@ org.gradle.jvmargs=-Xmx2G org.gradle.parallel=true -mod_version=1.1.2 +mod_version=1.1.6 mod_group_id=com.gastinelclaims mod_id=gastinelclaims diff --git a/src/main/java/com/gastinelclaims/core/RiptideTolerance.java b/src/main/java/com/gastinelclaims/core/RiptideTolerance.java new file mode 100644 index 0000000..ce8346a --- /dev/null +++ b/src/main/java/com/gastinelclaims/core/RiptideTolerance.java @@ -0,0 +1,25 @@ +package com.gastinelclaims.core; + +/** + * Seuil du contrôle « moved too quickly » pendant un riptide (logique pure, sans Minecraft). + * + * Vanilla refuse un déplacement si (distance² - vitesse attendue²) dépasse 100 × paquets. Un enchaînement de + * riptides dépasse 30 à 46 blocs par paquet (mesuré le 13/10/2026), d'où les retours en arrière. On relève le seuil + * uniquement pendant le riptide et juste après (l'élan continue), jamais en marche normale. + */ +public final class RiptideTolerance { + + /** 100 blocs par paquet, au carré (60 ne suffisait pas : sauts de 63 et 66 blocs relevés le 13/10). */ + public static final float SEUIL_RIPTIDE = 100f * 100f; + /** L'élan dure encore un peu après la fin de la vrille (2 s). */ + public static final int GRACE_TICKS = 40; + + private RiptideTolerance() { } + + public static float seuil(float seuilVanilla, boolean enVrille, int ticksDepuisVrille) { + if (enVrille || (ticksDepuisVrille >= 0 && ticksDepuisVrille <= GRACE_TICKS)) { + return Math.max(seuilVanilla, SEUIL_RIPTIDE); + } + return seuilVanilla; + } +} diff --git a/src/main/java/com/gastinelclaims/mixin/RiptideMoveMixin.java b/src/main/java/com/gastinelclaims/mixin/RiptideMoveMixin.java new file mode 100644 index 0000000..a163d18 --- /dev/null +++ b/src/main/java/com/gastinelclaims/mixin/RiptideMoveMixin.java @@ -0,0 +1,77 @@ +package com.gastinelclaims.mixin; + +import com.gastinelclaims.GastinelClaims; +import com.gastinelclaims.core.RiptideTolerance; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.server.network.ServerGamePacketListenerImpl; +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 net.minecraft.world.entity.Entity; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Constant; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; +import org.spongepowered.asm.mixin.injection.ModifyConstant; + +/** + * Plus de retour en arrière en enchaînant les riptides : seuil « moved too quickly » relevé quand le joueur tient + * un trident Impulsion (ou est en vrille), 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 + * pluie ou dans l'eau (biome, altitude), alors que le client la lance quand même (constaté le 13/10/2026). + */ +@Mixin(ServerGamePacketListenerImpl.class) +public abstract class RiptideMoveMixin { + + @Shadow public ServerPlayer player; + + @Unique private int gastinelclaims$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 gastinelclaims$seuilRiptide(float seuil) { + return gastinelclaims$seuil(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 gastinelclaims$seuilRiptideElytres(float seuil) { + return gastinelclaims$seuil(seuil); + } + + @Unique + private float gastinelclaims$seuil(float seuil) { + boolean riptide = player.isAutoSpinAttack() + || gastinelclaims$tridentImpulsion(player.getMainHandItem(), player) + || gastinelclaims$tridentImpulsion(player.getOffhandItem(), player); + if (riptide) gastinelclaims$dernierTickRiptide = player.tickCount; + int depuis = gastinelclaims$dernierTickRiptide == Integer.MIN_VALUE ? -1 : player.tickCount - gastinelclaims$dernierTickRiptide; + float resultat = RiptideTolerance.seuil(seuil, riptide, depuis); + if (resultat != seuil) { + GastinelClaims.LOGGER.debug("[GastinelClaims] riptide : seuil relevé pour {} (vrille={}, depuis={} ticks)", + player.getGameProfile().getName(), player.isAutoSpinAttack(), depuis); + } + return resultat; + } + + /** + * Contrôle anti-vol (allow-flight=false) : après une vrille, le joueur plane encore sur son élan et serait + * expulsé (« Flying is not enabled »). On lui laisse 10 s au lieu de 4 s, seulement juste après un riptide. + */ + @Inject(method = "getMaximumFlyingTicks", at = @At("RETURN"), cancellable = true) + private void gastinelclaims$volApresRiptide(Entity entity, CallbackInfoReturnable cir) { + if (entity != player || gastinelclaims$dernierTickRiptide == Integer.MIN_VALUE) return; + int depuis = player.tickCount - gastinelclaims$dernierTickRiptide; + if (depuis >= 0 && depuis <= RiptideTolerance.GRACE_TICKS) cir.setReturnValue(Math.max(cir.getReturnValue(), 200)); + } + + @Unique + private static boolean gastinelclaims$tridentImpulsion(ItemStack stack, ServerPlayer joueur) { + return stack.is(Items.TRIDENT) && EnchantmentHelper.getTridentSpinAttackStrength(stack, joueur) > 0.0F; + } +} diff --git a/src/main/resources/META-INF/neoforge.mods.toml b/src/main/resources/META-INF/neoforge.mods.toml index 6b7cb8d..988cb4d 100644 --- a/src/main/resources/META-INF/neoforge.mods.toml +++ b/src/main/resources/META-INF/neoforge.mods.toml @@ -4,7 +4,7 @@ license="MIT" [[mods]] modId="gastinelclaims" -version="1.1.2" +version="1.1.6" displayName="GastinelClaims" authors="Théo Gastinel" description='''Protection de terrains par chunk (/claim, /unclaim, /friend) et zones protégées (spawn incassable, /zoneprotegee). Mod côté serveur uniquement.''' diff --git a/src/main/resources/gastinelclaims.mixins.json b/src/main/resources/gastinelclaims.mixins.json index 097cb8c..dbf370a 100644 --- a/src/main/resources/gastinelclaims.mixins.json +++ b/src/main/resources/gastinelclaims.mixins.json @@ -3,6 +3,6 @@ "minVersion": "0.8", "package": "com.gastinelclaims.mixin", "compatibilityLevel": "JAVA_21", - "mixins": ["FlowingFluidMixin", "FireBlockMixin"], + "mixins": ["FlowingFluidMixin", "FireBlockMixin", "RiptideMoveMixin"], "injectors": {"defaultRequire": 1} } diff --git a/src/test/java/com/gastinelclaims/core/RiptideToleranceTest.java b/src/test/java/com/gastinelclaims/core/RiptideToleranceTest.java new file mode 100644 index 0000000..7681485 --- /dev/null +++ b/src/test/java/com/gastinelclaims/core/RiptideToleranceTest.java @@ -0,0 +1,29 @@ +package com.gastinelclaims.core; + +import org.junit.jupiter.api.Test; + +import static org.junit.jupiter.api.Assertions.*; + +class RiptideToleranceTest { + + @Test + void marcheNormale_seuilVanillaInchange() { + assertEquals(100f, RiptideTolerance.seuil(100f, false, -1)); + assertEquals(100f, RiptideTolerance.seuil(100f, false, RiptideTolerance.GRACE_TICKS + 1)); + } + + @Test + void pendantEtJusteApresLaVrille_seuilRiptide() { + assertEquals(RiptideTolerance.SEUIL_RIPTIDE, RiptideTolerance.seuil(100f, true, 0)); + assertEquals(RiptideTolerance.SEUIL_RIPTIDE, RiptideTolerance.seuil(100f, false, 10)); + assertEquals(RiptideTolerance.SEUIL_RIPTIDE, RiptideTolerance.seuil(100f, false, RiptideTolerance.GRACE_TICKS)); + } + + @Test + void sautsMesuresLe13Octobre_acceptes() { + // Plus grand saut relevé dans les journaux : 46,07 ; -4,10 ; -9,78 (blocs). + double d2 = 46.07 * 46.07 + 4.10 * 4.10 + 9.78 * 9.78; + assertTrue(d2 < RiptideTolerance.seuil(100f, true, 0)); + assertTrue(d2 > 100f); + } +}