diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index 05d7166..f03f821 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -44,6 +44,7 @@ Base avant corrections : 98 tests verts. ### F06 - `GardeEvents` : plus de marque de recul sur `LivingDamageEvent.Post`. La grâce vient de `LivingKnockBackEvent` (priorité basse, non annulé, force > 0 : tout `knockback()` vanilla, donc coups, projectiles, mace) et de `ExplosionKnockbackEvent` (explosions, **Wind Charge** : couvre aussi un cas « non géré » du README). Les dégâts du tag vanilla `no_knockback` (feu, lave, cactus, poison, wither, faim, chute, noyade) n'appellent pas `knockback()` : plus de grâce. +- Suite (revue de sécurité du commit F06) : une charge de vent lancée à ses pieds (source directe ou indirecte de l'explosion = le joueur) n'ouvre la grâce qu'une fois toutes les 3 s (`core/GraceRecul`, `F06_charge_de_vent_auto_infligee_limitee`, 114 verts). Les sauts honnêtes enchaînés à la charge de vent pourront lever des alertes `vitesse` en OBSERVE [À VÉRIFIER] en jeu. La vraie correction (élargir l'enveloppe de la vitesse reçue au lieu d'exempter) est le contrôle anti-knockback de la synthèse. - Reste : pistons, blocs de slime, poussées de mods tiers (non couverts, comme avant). ### F07 diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index c4e27cb..5b5af85 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -4,6 +4,7 @@ import com.gastinelgarde.core.Controle; import com.gastinelgarde.core.EtatJoueur; import com.gastinelgarde.core.EtatMouvement; import com.gastinelgarde.core.GardeConfig; +import com.gastinelgarde.core.GraceRecul; import com.gastinelgarde.core.GraceTeleport; import com.gastinelgarde.core.Mode; import com.gastinelgarde.core.Moteur; @@ -60,6 +61,7 @@ public final class Garde { int dernierTraceTick = Integer.MIN_VALUE; final RiptideSuivi riptide = new RiptideSuivi(); final GraceTeleport graceTeleport = new GraceTeleport(); + final GraceRecul graceRecul = new GraceRecul(); long exemptJusquaMs = 0; double dernierX, dernierY, dernierZ; boolean aDernierePosition; @@ -175,8 +177,12 @@ public final class Garde { m.mouvementTick = Integer.MIN_VALUE; } - public static void noterRecul(ServerPlayer p) { - marques(p.getUUID()).reculTick = p.server.getTickCount(); + /** Recul réel (F06). Auto-infligé (charge de vent à ses pieds) : grâce limitée, voir GraceRecul. */ + public static void noterRecul(ServerPlayer p, boolean autoInflige) { + if (!surThreadServeur(p)) return; + Marques m = marques(p.getUUID()); + int tick = p.server.getTickCount(); + if (m.graceRecul.recul(tick, autoInflige)) m.reculTick = tick; } public static void noterTickServeur(MinecraftServer server, long dureeNs) { diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index 58bc207..79d817b 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -97,14 +97,16 @@ public final class GardeEvents { @SubscribeEvent(priority = EventPriority.LOWEST) public static void onRecul(LivingKnockBackEvent event) { if (event.isCanceled() || event.getStrength() <= 0.0F) return; - if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterRecul(p); + if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterRecul(p, false); } - /** Explosion, charge de vent (Wind Charge) : poussée vers le joueur. */ + /** Explosion, charge de vent (Wind Charge) : poussée vers le joueur. Celle qu'il s'inflige est limitée (GraceRecul). */ @SubscribeEvent(priority = EventPriority.LOWEST) public static void onPousseeExplosion(ExplosionKnockbackEvent event) { if (event.getKnockbackVelocity().lengthSqr() <= 1.0E-6) return; - if (event.getAffectedEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterRecul(p); + if (!(event.getAffectedEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; + boolean auto = event.getExplosion().getIndirectSourceEntity() == p || event.getExplosion().getDirectSourceEntity() == p; + Garde.noterRecul(p, auto); } @SubscribeEvent diff --git a/src/main/java/com/gastinelgarde/core/GraceRecul.java b/src/main/java/com/gastinelgarde/core/GraceRecul.java new file mode 100644 index 0000000..5731a42 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/GraceRecul.java @@ -0,0 +1,22 @@ +package com.gastinelgarde.core; + +/** + * Quels reculs ouvrent la grâce de mouvement (F06). Un recul subi (coup, projectile, explosion d'un autre) l'ouvre + * toujours. Un recul que le joueur s'inflige lui-même (charge de vent à ses pieds) l'ouvre au plus une fois toutes + * les {@link #DELAI_AUTO_TICKS} ticks : sinon, une charge toutes les 10 ticks (temps de recharge vanilla) garderait + * tout le mouvement exempté en permanence (revue de sécurité du commit F06). + */ +public final class GraceRecul { + + public static final int DELAI_AUTO_TICKS = 60; + + private int dernierAuto = Integer.MIN_VALUE; + + /** @return vrai si ce recul ouvre la grâce */ + public boolean recul(int tick, boolean autoInflige) { + if (!autoInflige) return true; + if (dernierAuto != Integer.MIN_VALUE && tick >= dernierAuto && tick - dernierAuto < DELAI_AUTO_TICKS) return false; + dernierAuto = tick; + return true; + } +} diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index b930a18..e7da0af 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -231,4 +231,21 @@ class AuditFaillesTest { } assertFalse(vuRecul, "un vrai recul garde sa grâce"); } + + /** Revue de sécurité de F06 : une charge de vent à ses pieds toutes les 10 ticks n'exempte plus en continu. */ + @Test + void F06_charge_de_vent_auto_infligee_limitee() { + GraceRecul g = new GraceRecul(); + int reculTick = Integer.MIN_VALUE; + boolean vu = false; + for (int tick = 0; tick < 600; tick++) { + if (tick % 10 == 0 && g.recul(tick, true)) reculTick = tick; + int depuis = reculTick == Integer.MIN_VALUE ? EtatJoueur.JAMAIS : tick - reculTick; + EtatJoueur etat = EtatJoueur.builder().ticksDepuisRecul(depuis).build(); + if (!moteur.mouvement(j, tick * 50L, etat, mv(0.9, 0, 1, true, true)).isEmpty()) vu = true; + } + assertTrue(vu, "0,9 bloc/tick avec une charge de vent toutes les 0,5 s : vu"); + GraceRecul autre = new GraceRecul(); + for (int tick = 0; tick < 100; tick += 10) assertTrue(autre.recul(tick, false), "recul subi : toujours une grâce"); + } }