diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index d8d98ad..f1af3af 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -429,7 +429,7 @@ public final class Garde { if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return; MOTEUR.debutCasse(p.getUUID(), p.server.getTickCount(), pos.getX(), pos.getY(), pos.getZ()); // 0.5 (P2.5) : début de casse sans impact : face et portée seulement (journal, expulsion en ENFORCE). - List v = verdictsInteraction(p, pos, face, null); + List v = verdictsInteraction(p, pos, face, null, -1); Sanction s = traiter(p, v); if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v); } @@ -439,16 +439,16 @@ public final class Garde { * en ENFORCE, palier SETBACK ou plus) ; une EXPULSION est appliquée ici. Câblage non testé en jeu. */ public static boolean noterInteractionBloc(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face, - net.minecraft.world.phys.Vec3 impact) { + net.minecraft.world.phys.Vec3 impact, boolean mainPrincipale) { if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return false; - List v = verdictsInteraction(p, pos, face, impact); + List v = verdictsInteraction(p, pos, face, impact, mainPrincipale ? 0 : 1); Sanction s = traiter(p, v); if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v); return Cablage.sanctionDeMouvement(s); } private static List verdictsInteraction(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face, - net.minecraft.world.phys.Vec3 impact) { + net.minecraft.world.phys.Vec3 impact, int main) { if (CONFIG.mode(Controle.INTERACTION_BLOC) == Mode.OFF || estExempteManuellement(p.getUUID())) return List.of(); net.minecraft.world.level.Level l = p.level(); BlockState st = l.getBlockState(pos); @@ -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, pos.asLong(), etat(p, true), + return MOTEUR.interactionBloc(p.getUUID(), p.server.getTickCount() * 50L, pos.asLong(), main, 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 9c2ffe7..8ca09de 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -151,13 +151,15 @@ public final class GardeEvents { /** * 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. + * client vanilla envoie main principale puis secondaire au même tick sur le même bloc : compté une fois par le + * moteur, la main secondaire reprenant la décision (annulation) de la principale. */ @SubscribeEvent(priority = EventPriority.LOWEST) public static void onClicDroitBloc(net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.RightClickBlock event) { 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())) { + if (Garde.noterInteractionBloc(p, event.getPos(), event.getFace(), event.getHitVec().getLocation(), + event.getHand() == net.minecraft.world.InteractionHand.MAIN_HAND)) { event.setCanceled(true); } } diff --git a/src/main/java/com/gastinelgarde/core/InteractionBloc.java b/src/main/java/com/gastinelgarde/core/InteractionBloc.java index 4fa737d..fe74bfa 100644 --- a/src/main/java/com/gastinelgarde/core/InteractionBloc.java +++ b/src/main/java/com/gastinelgarde/core/InteractionBloc.java @@ -76,15 +76,50 @@ public final class InteractionBloc { return 2.0; } + // Dernier événement évalué (seconde revue : dédoublonnage du seul clic vanilla MAIN puis OFF). private long dernierMs = Long.MIN_VALUE; - private long derniereCle = Long.MIN_VALUE; + private long derniereCle; + private int derniereMain = -1; + private int derniereFace; + private double[] dernierImpact; + private long dedoublonneMs = Long.MIN_VALUE; + private java.util.List derniersVerdicts = java.util.List.of(); + private String derniereAnomalie; - /** 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; + /** Anomalie du dernier événement évalué (null si aucune). */ + public String derniereAnomalie() { + return derniereAnomalie; + } + + /** + * Vrai si cet événement est la main secondaire du clic vanilla qui vient d'être évalué en main principale : même + * instant, même bloc, même face, même point d'impact, et au plus une fois par instant. Tout le reste (deuxième + * événement identique de la même main, autre face, autre impact, troisième événement) est évalué normalement. + * + * @param main 0 = principale, 1 = secondaire + */ + public boolean secondeMainDuMemeClic(long nowMs, long cleBloc, int main, int face, double[] impact) { + return main == 1 && derniereMain == 0 && nowMs == dernierMs && cleBloc == derniereCle && face == derniereFace + && java.util.Arrays.equals(impact, dernierImpact) && dedoublonneMs != nowMs; + } + + /** La main secondaire dédoublonnée reprend la décision (verdicts) de la principale ; non recomptée. */ + public java.util.List reprendre(long nowMs) { + dedoublonneMs = nowMs; + derniereMain = 1; + return derniersVerdicts; + } + + /** Mémorise l'événement évalué et ses verdicts. */ + public void memoriser(long nowMs, long cleBloc, int main, int face, double[] impact, String anomalie, + java.util.List verdicts) { + derniereAnomalie = anomalie; dernierMs = nowMs; derniereCle = cleBloc; - return d; + derniereMain = main; + derniereFace = face; + dernierImpact = impact == null ? null : impact.clone(); + derniersVerdicts = java.util.List.copyOf(verdicts); } public int dernierCompte() { diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index 17fca1d..3f6b81b 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -527,27 +527,36 @@ 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); + return interactionBloc(joueur, nowMs, Long.MIN_VALUE, -1, 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. + * Idem, avec la position du bloc ({@code BlockPos.asLong}) et la main (0 principale, 1 secondaire, -1 inconnue). + * Seconde revue de sécurité : seul le clic vanilla « main principale puis secondaire » (même instant, bloc, face et + * impact, une fois par instant) n'est compté qu'une fois ; la main secondaire reprend alors les verdicts de la + * principale, donc la même décision d'annulation. Tout autre événement est évalué normalement. */ - 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) { + public List interactionBloc(UUID joueur, long nowMs, long cleBloc, int main, 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); + // La vérification tourne toujours ; seul le comptage est sauté pour la main secondaire du même clic, et seulement + // si elle donne la même anomalie que la principale : elle reprend alors ses verdicts (même décision d'annulation). + if (cleBloc != Long.MIN_VALUE && s.interactionBloc.secondeMainDuMemeClic(nowMs, cleBloc, main, face, impact) + && java.util.Objects.equals(a, s.interactionBloc.derniereAnomalie())) { + return new ArrayList<>(s.interactionBloc.reprendre(nowMs)); + } double pts = s.interactionBloc.enregistrer(nowMs, a, cfg); List v = new ArrayList<>(1); ajouter(v, s, Controle.INTERACTION_BLOC, pts, nowMs, ex, String.format(Locale.ROOT, "%s (%s), %d anomalies sur %d interactions", a, impact == null ? "debut de casse" : "clic droit", s.interactionBloc.dernierCompte(), InteractionBloc.SERIE)); + s.interactionBloc.memoriser(nowMs, cleBloc, main, face, impact, a, v); return v; } diff --git a/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java b/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java index aa66979..031cc29 100644 --- a/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java +++ b/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java @@ -4,6 +4,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertTrue; +import java.util.List; import java.util.UUID; import org.junit.jupiter.api.Test; @@ -96,26 +97,77 @@ class InteractionBlocP2Test { } } - /** Revue de sécurité : la main secondaire seule est mesurée ; les deux mains d'un même clic comptent une fois. */ + // --- Revues de sécurité (main secondaire, doublons) --- + + private static final double[] OEIL = {0.5, 66.62, 2}; + private static final double[] IMPACT = {0.5, 65, 0.5}; + + private List clic(Moteur m, long t, long cle, int main, int face, double[] impact, boolean air) { + return m.interactionBloc(joueur, t, cle, main, EtatJoueur.normal(), OEIL, CUBE, face, impact, air, true, 4.5, 0); + } + + private static double pts(List v) { + return v.stream().filter(x -> x.controle() == Controle.INTERACTION_BLOC).mapToDouble(Verdict::points).sum(); + } + @Test - void mainSecondaireCompteeEtDoublonsIgnores() { + void mainSecondaireSeuleMesuree() { + Moteur m = new Moteur(cfg); + double p = 0; + for (int i = 0; i < 3; i++) p += pts(clic(m, i * 500L, 100L + i, 1, HAUT, IMPACT, true)); + assertTrue(p > 0, "3 clics forgés en main secondaire seule suffisent"); + } + + @Test + void doublonVanillaMainPuisSecondaireCompteUneFoisEtGardeLaDecision() { 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(); - } + clic(m, i * 500L, 7L, 0, HAUT, IMPACT, true); + clic(m, i * 500L, 7L, 1, HAUT, IMPACT, true); } - 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); + assertEquals(2, m.suivi(joueur).interactionBloc.dernierCompte(), "2 clics (4 événements) = 2 anomalies"); + // 3e clic : la principale atteint la série ; la secondaire reprend exactement ses verdicts (même annulation). + List principale = clic(m, 1000L, 7L, 0, HAUT, IMPACT, true); + List secondaire = clic(m, 1000L, 7L, 1, HAUT, IMPACT, true); + assertTrue(pts(principale) > 0); + assertEquals(principale, secondaire, "un doublon ne se lit jamais comme autorisé"); + assertEquals(3, m.suivi(joueur).interactionBloc.dernierCompte(), "non recompté"); + } + + @Test + void deuxiemeEvenementIdentiqueDeLaMemeMainEvalue() { + Moteur m = new Moteur(cfg); + double p = 0; + for (int k = 0; k < 3; k++) p += pts(clic(m, 500L, 7L, 0, HAUT, IMPACT, true)); // 3 fois la principale, même tick + assertTrue(p > 0, "les répétitions de la même main comptent"); + // secondaire répétée : dédoublonnée une seule fois par tick + Moteur m2 = new Moteur(cfg); + clic(m2, 500L, 7L, 0, HAUT, IMPACT, true); + clic(m2, 500L, 7L, 1, HAUT, IMPACT, true); + clic(m2, 500L, 7L, 1, HAUT, IMPACT, true); + assertEquals(2, m2.suivi(joueur).interactionBloc.dernierCompte()); + } + + @Test + void secondaireAvecAutreFaceOuImpactEvaluee() { + Moteur m = new Moteur(cfg); + clic(m, 500L, 7L, 0, HAUT, IMPACT, false); + // même tick, même bloc, main secondaire mais face du bas vue d'en haut : vérifiée et comptée + clic(m, 500L, 7L, 1, BAS, new double[] {0.5, 64, 0.5}, false); + assertEquals(1, m.suivi(joueur).interactionBloc.dernierCompte()); + clic(m, 600L, 7L, 0, HAUT, IMPACT, false); + clic(m, 600L, 7L, 1, HAUT, new double[] {0.5, 64.5, 0.5}, false); // impact forgé au centre + assertEquals(2, m.suivi(joueur).interactionBloc.dernierCompte()); + } + + @Test + void rafaleSurLeMemeBlocDetectee() { + Moteur m = new Moteur(cfg); + double p = 0; + for (int k = 0; k < 10; k++) { + p += pts(clic(m, 500L, 7L, 0, HAUT, IMPACT, true)); + p += pts(clic(m, 500L, 7L, 1, HAUT, IMPACT, true)); + } + assertTrue(p > 0, "rafale de 20 événements dans un tick sur un bloc d'air"); } }