F04 (suite) : relachement sans vrille serveur limite et pluie proche exigee

Revue de securite : la pluie dans la dimension seule ouvrait la tolerance. 107 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:35:38 +02:00
1 Parent f744e15108
révision dde883d25d
4 fichiers modifiés
+68 -13

Aucun fichier ne correspond à votre recherche

+18 -1
Voir le fichier
@@ -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;
+31 -9
Voir le fichier
@@ -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. */
+17 -2
Voir le fichier
@@ -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