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 à :
1 Parent
f744e15108
révision
dde883d25d
4 fichiers modifiés
+68
-13
Aucun fichier ne correspond à votre recherche
@@ -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
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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. */
|
||||
|
||||
@@ -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
|
||||
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur