From 5f10d871b88762c6c23adfd0e4d1fcb1ae3381bc Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Wed, 14 Oct 2026 08:37:14 +0200 Subject: [PATCH] F06 : la grace de recul ne vient plus que d'un recul reel LivingKnockBackEvent et ExplosionKnockbackEvent (dont Wind Charge) au lieu de tout degat. 109 tests. Co-Authored-By: Claude Opus 5.5 --- audit/CORRECTIONS.md | 6 ++++- .../java/com/gastinelgarde/GardeEvents.java | 24 +++++++++++++---- .../com/gastinelgarde/AdaptateursTest.java | 13 +++++++++ .../gastinelgarde/core/AuditFaillesTest.java | 27 +++++++++++++++++++ 4 files changed, 64 insertions(+), 6 deletions(-) diff --git a/audit/CORRECTIONS.md b/audit/CORRECTIONS.md index e7e51dc..d280325 100644 --- a/audit/CORRECTIONS.md +++ b/audit/CORRECTIONS.md @@ -11,7 +11,7 @@ Base avant corrections : 98 tests verts. | F01 thread réseau | corrigée | voir `git log --grep F01` | `MixinsThreadTest` (2, rouges avant), `AuditFaillesTest.F01_*` ; 101 verts | essai en jeu n° 1 (aucune ligne `timer` en marchant) | | F04 riptide tenu | corrigée | `git log --grep F04` | `AuditFaillesTest.F04_*` (3) ; 104 verts | essai en jeu n° 2 ; retirer le mixin de GastinelClaims 1.1.6 (sinon F04 reste ouverte) ; seuil de 100 blocs/paquet pendant la vrille gardé [À VÉRIFIER] | | F05 grâce téléportation | corrigée | `git log --grep F05` | `AuditFaillesTest.F05_*` (2) ; 106 verts | essai en jeu : `/tp`, perle, TPA, portail sans fausse alerte | -| F06 grâce dégâts | à faire | | | | +| F06 grâce dégâts | corrigée | `git log --grep F06` | `AuditFaillesTest.F06_*`, `AdaptateursTest.F06_*` ; 109 verts | essai en jeu : Wind Charge, explosion, coup d'épée : aucune fausse alerte | | F07 ping | à faire | | | | | F08 vol aveugle | à faire | | | | | F02 timer inondation | à faire | | | | @@ -41,3 +41,7 @@ Base avant corrections : 98 tests verts. - Nouveau `core/GraceTeleport` : origine de chaque `teleport()`. Le mixin annonce `REFUS_VANILLA` avant les 3 `teleport(DDDFF)V` de `handleMovePlayer` (lit, « moved too quickly », « moved wrongly » ; javap : offsets 360, 606, 1322) et `RENVOI` avant celui de `updateAwaitingTeleport` ; `Garde.appliquerSanctionMouvement` annonce `SETBACK`. Seule l'origine `EXTERNE` (sans annonce : commande, perle, TPA, autre mod) ouvre la grâce ; un renvoi garde l'origine précédente. Connexion, dimension, réapparition : grâce comme avant (événements). - Après toute téléportation, le mouvement suivant n'est plus comparé à la position d'avant (`mouvementTick` remis à zéro), d'où plus besoin de grâce pour le refus ou le setback. - Le timer garde la grâce des téléportations externes seulement. + +### 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. +- Reste : pistons, blocs de slime, poussées de mods tiers (non couverts, comme avant). diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index 81e1f02..58bc207 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -10,17 +10,19 @@ import net.minecraft.server.level.ServerPlayer; import net.minecraft.world.entity.Entity; import net.minecraft.world.phys.AABB; import net.minecraft.world.phys.Vec3; +import net.neoforged.bus.api.EventPriority; import net.neoforged.bus.api.SubscribeEvent; import net.neoforged.neoforge.common.util.FakePlayer; -import net.neoforged.neoforge.event.entity.living.LivingDamageEvent; +import net.neoforged.neoforge.event.entity.living.LivingKnockBackEvent; import net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent; import net.neoforged.neoforge.event.entity.player.AttackEntityEvent; import net.neoforged.neoforge.event.entity.player.PlayerEvent; +import net.neoforged.neoforge.event.level.ExplosionKnockbackEvent; import net.neoforged.neoforge.event.server.ServerStartingEvent; import net.neoforged.neoforge.event.server.ServerStoppedEvent; import net.neoforged.neoforge.event.tick.ServerTickEvent; -/** Collecte des faits côté serveur (D3) : coups, déconnexions, téléportations, reculs, durée des ticks. */ +/** Collecte des faits côté serveur (D3) : coups, déconnexions, téléportations, reculs réels, durée des ticks. */ public final class GardeEvents { private static long debutTickNs; @@ -88,9 +90,21 @@ public final class GardeEvents { } } - @SubscribeEvent - public static void onDegats(LivingDamageEvent.Post event) { - if (event.getEntity() instanceof ServerPlayer p) Garde.noterRecul(p); + /** + * F06 : la grâce de recul ne s'ouvre que si une vitesse est réellement donnée au joueur. Un dégât sans recul + * (feu, cactus, poison, wither, faim, chute : tag vanilla no_knockback) ne déclenche pas knockback(). + */ + @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); + } + + /** Explosion, charge de vent (Wind Charge) : poussée vers le joueur. */ + @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); } @SubscribeEvent diff --git a/src/test/java/com/gastinelgarde/AdaptateursTest.java b/src/test/java/com/gastinelgarde/AdaptateursTest.java index e7999ca..f21134d 100644 --- a/src/test/java/com/gastinelgarde/AdaptateursTest.java +++ b/src/test/java/com/gastinelgarde/AdaptateursTest.java @@ -61,4 +61,17 @@ class AdaptateursTest { Garde.definirTraces(true); assertFalse(Garde.tracesEnCours()); } + + /** F06 : la grâce de recul vient des événements de recul, plus des dégâts. */ + @Test + void F06_le_recul_vient_des_evenements_de_poussee() { + java.util.Set> evenements = new java.util.HashSet<>(); + for (java.lang.reflect.Method m : GardeEvents.class.getDeclaredMethods()) { + if (m.isAnnotationPresent(net.neoforged.bus.api.SubscribeEvent.class)) evenements.add(m.getParameterTypes()[0]); + } + assertTrue(evenements.contains(net.neoforged.neoforge.event.entity.living.LivingKnockBackEvent.class)); + assertTrue(evenements.contains(net.neoforged.neoforge.event.level.ExplosionKnockbackEvent.class)); + assertFalse(evenements.contains(net.neoforged.neoforge.event.entity.living.LivingDamageEvent.Post.class), + "un dégât seul (feu, cactus) ne doit plus ouvrir la grâce"); + } } diff --git a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java index 73c3116..d34805c 100644 --- a/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java +++ b/src/test/java/com/gastinelgarde/core/AuditFaillesTest.java @@ -143,4 +143,31 @@ class AuditFaillesTest { g.annoncer(GraceTeleport.Origine.REFUS_VANILLA); assertFalse(g.teleport()); } + + // ---------------------------------------------------------------- F06 + /** + * Avant : tout dégât (feu, cactus, wither) ouvrait 20 ticks de grâce ; se blesser chaque seconde exemptait en + * permanence. Maintenant seul un recul réel (LivingKnockBackEvent, ExplosionKnockbackEvent) marque le joueur : + * un dégât sans recul laisse ticksDepuisRecul inchangé (adaptateur vérifié par AdaptateursTest). + */ + @Test + void F06_degats_sans_recul_n_exemptent_plus() { + long now = 0; + boolean vu = false; + for (int tick = 0; tick < 600; tick++) { + // un dégât de feu chaque seconde : aucun appel à knockback(), donc aucune marque de recul + EtatJoueur etat = EtatJoueur.builder().ticksDepuisRecul(EtatJoueur.JAMAIS).build(); + if (!moteur.mouvement(j, now, etat, mv(0.9, 0, 1, true, true)).isEmpty()) vu = true; + now += 50; + } + assertTrue(vu, "0,9 bloc/tick en se brûlant : vu"); + + UUID recul = UUID.randomUUID(); + boolean vuRecul = false; + for (int tick = 0; tick < 15; tick++) { + EtatJoueur etat = EtatJoueur.builder().ticksDepuisRecul(tick).build(); // vrai recul au tick 0 + if (!moteur.mouvement(recul, tick * 50L, etat, mv(0.9, 0, 1, true, true)).isEmpty()) vuRecul = true; + } + assertFalse(vuRecul, "un vrai recul garde sa grâce"); + } }