From ba37380d8ebc5a4e1b2feada6732df40b44f5a1d Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Sat, 24 Oct 2026 00:59:31 +0200 Subject: [PATCH] P2.5 (revue) : interaction-bloc mesure aussi la main secondaire - Revue de securite : l'ecouteur RightClickBlock filtrait MAIN_HAND ; un client force pouvait n'envoyer que la main secondaire et echapper au controle (le defaut etait dans interaction-bloc, pas dans fast-place). - Les deux mains sont mesurees ; le clic vanilla (principale puis secondaire, meme tick, meme bloc) est dedoublonne par InteractionBloc.doublon (instant + BlockPos.asLong), nouvelle surcharge Moteur.interactionBloc. - Autres ecouteurs P2 verifies, sans filtre de main : fast-place (EntityPlaceEvent, toutes mains), fast-break (LeftClickBlock / BreakEvent, pas de main), no-slow (isUsingItem, toutes mains), auto-totem(-regulier) (deux mains lues). - Test : InteractionBlocP2Test.mainSecondaireCompteeEtDoublonsIgnores. Co-Authored-By: Claude Sonnet 5.5 --- src/main/java/com/gastinelgarde/Garde.java | 2 +- .../java/com/gastinelgarde/GardeEvents.java | 7 ++++-- .../gastinelgarde/core/InteractionBloc.java | 11 +++++++++ .../java/com/gastinelgarde/core/Moteur.java | 10 ++++++++ .../core/InteractionBlocP2Test.java | 23 +++++++++++++++++++ 5 files changed, 50 insertions(+), 3 deletions(-) diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 5fb5d6d..d8d98ad 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -461,7 +461,7 @@ public final class Garde { deplacement = Math.sqrt(Math.pow(m.oeilDernier[0] - m.oeilAvant[0], 2) + Math.pow(m.oeilDernier[1] - m.oeilAvant[1], 2) + Math.pow(m.oeilDernier[2] - m.oeilAvant[2], 2)); } - return MOTEUR.interactionBloc(p.getUUID(), p.server.getTickCount() * 50L, etat(p, true), + return MOTEUR.interactionBloc(p.getUUID(), p.server.getTickCount() * 50L, pos.asLong(), etat(p, true), new double[] {oeil.x, oeil.y, oeil.z}, new double[] {b.minX, b.minY, b.minZ, b.maxX, b.maxY, b.maxZ}, face == null ? -1 : face.get3DDataValue(), impact == null ? null : new double[] {impact.x, impact.y, impact.z}, st.isAir(), st.isCollisionShapeFullBlock(l, pos), p.blockInteractionRange(), deplacement); diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index 8b31bff..9c2ffe7 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -149,10 +149,13 @@ public final class GardeEvents { if (Garde.noterCasse(p, event.getPos(), event.getState())) event.setCanceled(true); } - /** 0.5 (P2.5) : clic droit sur un bloc (main principale seulement : le client essaie toujours celle-ci d'abord). */ + /** + * 0.5 (P2.5) : clic droit sur un bloc, les deux mains (un client forgé peut n'envoyer que la main secondaire). Le + * client vanilla envoie main principale puis secondaire au même tick sur le même bloc : dédoublonné par le moteur. + */ @SubscribeEvent(priority = EventPriority.LOWEST) public static void onClicDroitBloc(net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.RightClickBlock event) { - if (event.getLevel().isClientSide() || event.getHand() != net.minecraft.world.InteractionHand.MAIN_HAND) return; + if (event.getLevel().isClientSide()) return; if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; if (Garde.noterInteractionBloc(p, event.getPos(), event.getFace(), event.getHitVec().getLocation())) { event.setCanceled(true); diff --git a/src/main/java/com/gastinelgarde/core/InteractionBloc.java b/src/main/java/com/gastinelgarde/core/InteractionBloc.java index 404809b..4fa737d 100644 --- a/src/main/java/com/gastinelgarde/core/InteractionBloc.java +++ b/src/main/java/com/gastinelgarde/core/InteractionBloc.java @@ -76,6 +76,17 @@ public final class InteractionBloc { return 2.0; } + private long dernierMs = Long.MIN_VALUE; + private long derniereCle = Long.MIN_VALUE; + + /** Même instant et même bloc que l'interaction précédente (l'autre main du même clic) : vrai, à ne pas compter. */ + public boolean doublon(long nowMs, long cleBloc) { + boolean d = nowMs == dernierMs && cleBloc == derniereCle; + dernierMs = nowMs; + derniereCle = cleBloc; + return d; + } + public int dernierCompte() { return dernierCompte; } diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index f08a383..17fca1d 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -527,10 +527,20 @@ public final class Moteur { */ public List interactionBloc(UUID joueur, long nowMs, EtatJoueur etat, double[] oeil, double[] boite, int face, double[] impact, boolean air, boolean plein, double portee, double deplacement) { + return interactionBloc(joueur, nowMs, Long.MIN_VALUE, etat, oeil, boite, face, impact, air, plein, portee, deplacement); + } + + /** + * Idem, avec la position du bloc ({@code BlockPos.asLong}) : deux interactions au même instant sur le même bloc (main + * principale puis secondaire du même clic) ne comptent qu'une fois. {@code Long.MIN_VALUE} = pas de dédoublonnage. + */ + public List interactionBloc(UUID joueur, long nowMs, long cleBloc, EtatJoueur etat, double[] oeil, double[] boite, + int face, double[] impact, boolean air, boolean plein, double portee, double deplacement) { if (expulses.contains(joueur) || cfg.mode(Controle.INTERACTION_BLOC) == Mode.OFF) return List.of(); Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE); if (ex.exempt()) return List.of(); Suivi s = suivi(joueur); + if (cleBloc != Long.MIN_VALUE && s.interactionBloc.doublon(nowMs, cleBloc)) return List.of(); double marge = (cfg.interactionBlocMarge + Math.max(0, Math.min(deplacement, 5.0))) * ex.facteur(); String a = InteractionBloc.anomalie(oeil, boite, face, impact, air, plein, portee, marge); double pts = s.interactionBloc.enregistrer(nowMs, a, cfg); diff --git a/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java b/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java index 46f4d93..aa66979 100644 --- a/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java +++ b/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java @@ -95,4 +95,27 @@ class InteractionBlocP2Test { assertEquals(0, serie(new Moteur(cfg), e, 10, true), 1e-9, e.toString()); } } + + /** Revue de sécurité : la main secondaire seule est mesurée ; les deux mains d'un même clic comptent une fois. */ + @Test + void mainSecondaireCompteeEtDoublonsIgnores() { + Moteur m = new Moteur(cfg); + double pts = 0; + int verdicts = 0; + for (int i = 0; i < 3; i++) { + // clic forgé en main secondaire seule (adaptateur : même appel quelle que soit la main), sur de l'air + for (Verdict v : m.interactionBloc(joueur, i * 500L, 100L + i, EtatJoueur.normal(), new double[] {0.5, 66.62, 2}, + CUBE, HAUT, new double[] {0.5, 65, 0.5}, true, true, 4.5, 0)) pts += v.points(); + } + assertTrue(pts > 0, "3 clics d'une seule main suffisent"); + Moteur m2 = new Moteur(cfg); + for (int i = 0; i < 2; i++) { + for (int main = 0; main < 2; main++) { // principale puis secondaire, même tick, même bloc + verdicts += m2.interactionBloc(joueur, i * 500L, 7L, EtatJoueur.normal(), new double[] {0.5, 66.62, 2}, + CUBE, HAUT, new double[] {0.5, 65, 0.5}, true, true, 4.5, 0).size(); + } + } + assertEquals(0, verdicts, "2 clics (4 événements) : 2 anomalies comptées, sous la série de 3"); + assertTrue(m2.suivi(joueur).interactionBloc.dernierCompte() == 2); + } }