diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index d94eaa8..916e1a5 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -33,7 +33,8 @@ Base avant corrections : 98 tests verts. ### 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. +- Suite (revue de sécurité du commit F04) : la pluie « dans le monde » seule ne suffit plus. Un relâchement sans vrille serveur (non confirmé) exige une pluie proche (temps pluvieux, biome pluvieux, ciel visible jusqu'à 3 blocs au-dessus de la tête) et reste limité à 3 par 10 s (`F04_relachements_non_confirmes_limites`, 107 verts). Dans l'eau ou sous la pluie vue par le serveur, la vrille est réelle : pas de limite. +- Reste ouvert : sous une vraie pluie, un enchaînement de riptides honnête et une boucle de triche se ressemblent (indiscernables 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 diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 1db0d80..0a5fa12 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -262,13 +262,30 @@ public final class Garde { 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()); + p.isInWaterOrRain(), pluieProche(p)); if (ouvert) { GastinelGarde.LOGGER.debug("[GastinelGarde] riptide : relâchement de {} (charge {} ticks)", p.getGameProfile().getName(), charge); } } + /** + * Critère de pluie relâché par rapport à isInWaterOrRain (le client peut voir la pluie quand le serveur ne la + * voit pas : niveau de pluie qui monte, hauteur) : temps pluvieux, biome pluvieux et ciel visible à moins de + * 3 blocs au-dessus de la tête. Un toit ou un temps sec : non. + */ + private static boolean pluieProche(ServerPlayer p) { + net.minecraft.world.level.Level l = p.level(); + if (!l.getLevelData().isRaining() && l.getRainLevel(1.0F) <= 0.0F) return false; + BlockPos tete = BlockPos.containing(p.getX(), p.getBoundingBox().maxY, p.getZ()); + for (int dy = -1; dy <= 3; dy++) { + BlockPos pos = tete.above(dy); + if (l.canSeeSky(pos) && l.getBiome(pos).value().getPrecipitationAt(pos) + == net.minecraft.world.level.biome.Biome.Precipitation.RAIN) return true; + } + return false; + } + /** 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; diff --git a/src/main/java/com/gastinelgarde/core/RiptideSuivi.java b/src/main/java/com/gastinelgarde/core/RiptideSuivi.java index 8798abe..ae9857e 100644 --- a/src/main/java/com/gastinelgarde/core/RiptideSuivi.java +++ b/src/main/java/com/gastinelgarde/core/RiptideSuivi.java @@ -6,15 +6,25 @@ package com.gastinelgarde.core; * {@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. + * (biome, altitude, niveau de pluie) alors que le client la lance quand même (constaté le 13/10/2026). Un tel + * relâchement « non confirmé » exige une pluie proche vue par le serveur (pluie dans le monde, ciel visible juste + * au-dessus du joueur, biome pluvieux) et reste limité à {@link #MAX_NON_CONFIRMES} par + * {@link #FENETRE_NON_CONFIRMES_TICKS} ticks : charger puis relâcher en boucle sous un toit ou par temps sec ne + * rouvre plus la tolérance. */ 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; + /** Relâchements sans vrille côté serveur tolérés par fenêtre (décalage client/serveur de la pluie). */ + public static final int MAX_NON_CONFIRMES = 3; + public static final int FENETRE_NON_CONFIRMES_TICKS = 200; + private int dernierTick = Integer.MIN_VALUE; + private final int[] nonConfirmes = new int[MAX_NON_CONFIRMES]; + private int nbNonConfirmes; + private int indexNonConfirmes; /** À chaque mouvement : le serveur voit-il le joueur en vrille (isAutoSpinAttack) ? */ public void observer(int tick, boolean vrilleServeur) { @@ -26,19 +36,31 @@ public final class RiptideSuivi { * * @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) + * @param eauOuPluie le serveur voit le joueur dans l'eau ou sous la pluie (il lance la vrille) + * @param pluieProche il pleut juste au-dessus du joueur selon un critère relâché (le client peut juger + * la pluie autrement que le serveur) * @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; + public boolean relache(int tick, boolean tridentImpulsion, int ticksCharge, boolean eauOuPluie, boolean pluieProche) { + if (!tridentImpulsion || ticksCharge < CHARGE_MIN_TICKS) return false; + if (!eauOuPluie) { + if (!pluieProche || !accepterNonConfirme(tick)) 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); + private boolean accepterNonConfirme(int tick) { + int recents = 0; + for (int i = 0; i < nbNonConfirmes; i++) { + int t = nonConfirmes[i]; + if (tick >= t && tick - t < FENETRE_NON_CONFIRMES_TICKS) recents++; + } + if (recents >= MAX_NON_CONFIRMES) return false; + nonConfirmes[indexNonConfirmes] = tick; + indexNonConfirmes = (indexNonConfirmes + 1) % MAX_NON_CONFIRMES; + nbNonConfirmes = Math.min(MAX_NON_CONFIRMES, nbNonConfirmes + 1); + return true; } /** Ticks depuis la dernière vrille ou le dernier relâchement valide, -1 si jamais. */ diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index d866515..73c3116 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -84,12 +84,27 @@ class AuditFaillesTest { 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)"); + assertFalse(r.relache(0, true, 30, false, false), "temps sec, sous un toit ou hors de l'eau : rien"); + assertTrue(r.relache(100, true, 12, false, true), "pluie juste au-dessus, pas vue par isInWaterOrRain (cas du 13/10)"); assertTrue(r.actif(100 + RiptideTolerance.GRACE_TICKS)); assertFalse(r.actif(101 + RiptideTolerance.GRACE_TICKS)); } + /** Revue de sécurité de F04 : charger puis relâcher en boucle sans vrille serveur ne garde plus la tolérance. */ + @Test + void F04_relachements_non_confirmes_limites() { + RiptideSuivi r = new RiptideSuivi(); + int ouverts = 0; + for (int tick = 0; tick < RiptideSuivi.FENETRE_NON_CONFIRMES_TICKS; tick += 11) { + if (r.relache(tick, true, 10, false, true)) ouverts++; + } + assertEquals(RiptideSuivi.MAX_NON_CONFIRMES, ouverts, "au plus 3 relâchements sans vrille serveur par 10 s"); + assertFalse(r.actif(198 + RiptideTolerance.GRACE_TICKS), "la boucle ne garde pas l'exemption"); + + RiptideSuivi eau = new RiptideSuivi(); + for (int tick = 0; tick < 400; tick += 11) assertTrue(eau.relache(tick, true, 10, true, false), "dans l'eau : vrille serveur, pas de limite"); + } + // ---------------------------------------------------------------- F05 /** * Avant : un paquet volontairement trop rapide toutes les 1,5 s faisait téléporter le joueur par vanilla, et