From 5397ea8c6e6b877dcda11f99f6d866d4bf834315 Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Sat, 24 Oct 2026 00:55:42 +0200 Subject: [PATCH] P2.5 : nouveau controle interaction-bloc (OBSERVE par defaut) - core.InteractionBloc : clic droit sur un bloc (RightClickBlock, main principale) ou debut de casse (LeftClickBlock START, sans impact) impossible pour le rayon du client vanilla : bloc d'air (AirPlace), oeil derriere le plan de la face cliquee (a travers un bloc, Scaffold simple), impact hors de la face d'un bloc plein (vecteur forge), portee de bloc + marge depassee. - Marge interactionBlocMarge (0,5) + deplacement de l'oeil au dernier tick (le rayon du client part de l'oeil interpole). Au-dela de portee + 1 vanilla refuse (handleUseItemOn, verifie dans les sources NeoForge 21.1.234) : si l'evenement arrive quand meme, un mod a transforme les coordonnees (Sable), rien n'est mesure. Forme de contour reelle du bloc (dalles, escaliers). - Points en serie : interactionBlocSerieMin (3) anomalies sur les 10 dernieres interactions en 60 s. Exemptions MONDE (creatif, spectateur, contraption, gel, connexion). En ENFORCE au palier SETBACK le clic droit est annule ; le debut de casse n'est jamais annule (expulsion seulement). - Reglages [monde] : interactionBlocMarge, interactionBlocSerieMin. - Tests : InteractionBlocP2Test (7). Cablage non teste en jeu. Co-Authored-By: Claude Sonnet 5.5 --- src/main/java/com/gastinelgarde/Garde.java | 39 +++++++- .../java/com/gastinelgarde/GardeEvents.java | 12 ++- .../java/com/gastinelgarde/GardeSpec.java | 10 +- .../java/com/gastinelgarde/core/Controle.java | 6 +- .../com/gastinelgarde/core/GardeConfig.java | 4 + .../gastinelgarde/core/InteractionBloc.java | 97 ++++++++++++++++++ .../java/com/gastinelgarde/core/Moteur.java | 20 ++++ .../java/com/gastinelgarde/core/Suivi.java | 2 + .../core/InteractionBlocP2Test.java | 98 +++++++++++++++++++ 9 files changed, 283 insertions(+), 5 deletions(-) create mode 100644 src/main/java/com/gastinelgarde/core/InteractionBloc.java create mode 100644 src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 116df62..345e12f 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -425,9 +425,46 @@ public final class Garde { } } /** 0.5 (P2.3) : START de casse accepté : début de la mesure fast-break. */ - public static void noterDebutCasse(ServerPlayer p, BlockPos pos) { + public static void noterDebutCasse(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face) { 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); + Sanction s = traiter(p, v); + if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v); + } + + /** + * 0.5 (P2.5) : clic droit sur un bloc (main principale). Vrai si l'interaction doit être annulée (interaction-bloc + * 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) { + if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return false; + List v = verdictsInteraction(p, pos, face, impact); + 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) { + 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); + net.minecraft.world.phys.shapes.VoxelShape forme = st.getShape(l, pos); + net.minecraft.world.phys.AABB b = forme.isEmpty() ? new net.minecraft.world.phys.AABB(pos) : forme.bounds().move(pos); + net.minecraft.world.phys.Vec3 oeil = p.getEyePosition(); + Marques m = marques(p.getUUID()); + double deplacement = 0; + if (m.oeilDernier != null && m.oeilAvant != null) { + 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), + 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 af0a731..8b31bff 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -132,7 +132,7 @@ public final class GardeEvents { var a = event.getAction(); // 0.5 (P2.3) : début de la mesure fast-break (START accepté par les autres mods). if (a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START && !event.isCanceled()) { - Garde.noterDebutCasse(p, event.getPos()); + Garde.noterDebutCasse(p, event.getPos(), event.getFace()); } Garde.noterActionBloc(p, a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.START, a == net.neoforged.neoforge.event.entity.player.PlayerInteractEvent.LeftClickBlock.Action.ABORT, @@ -149,6 +149,16 @@ 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). */ + @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.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; + if (Garde.noterInteractionBloc(p, event.getPos(), event.getFace(), event.getHitVec().getLocation())) { + event.setCanceled(true); + } + } + /** 0.5 (P2.4) : bloc posé par un joueur (fast-place). En ENFORCE au palier SETBACK, la pose est annulée. */ @SubscribeEvent(priority = EventPriority.LOWEST) public static void onPose(net.neoforged.neoforge.event.level.BlockEvent.EntityPlaceEvent event) { diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index 8af86b2..05a451f 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -33,7 +33,8 @@ public final class GardeSpec { private static final ModConfigSpec.DoubleValue FAST_BREAK_FACTEUR; private static final ModConfigSpec.IntValue FAST_BREAK_TICKS_MIN, FAST_BREAK_SERIE; private static final ModConfigSpec.IntValue FAST_PLACE_SERIE, FAST_PLACE_INTERVALLE; - private static final ModConfigSpec.DoubleValue FAST_PLACE_REGULARITE; + private static final ModConfigSpec.DoubleValue FAST_PLACE_REGULARITE, INTER_MARGE; + private static final ModConfigSpec.IntValue INTER_SERIE; private static final ModConfigSpec.DoubleValue ANGLE_MAX; private static final ModConfigSpec.IntValue CIBLES_MAX; @@ -296,6 +297,11 @@ public final class GardeSpec { .defineInRange("fastPlaceRegularite", 0.9, 0.5, 1.0); FAST_PLACE_INTERVALLE = b.comment("Fast-place : cet intervalle commun (ticks) au plus. Vanilla au clic maintenu : 4. 2 = attrape aussi le délai 1.") .defineInRange("fastPlaceIntervalleMaxTicks", 1, 1, 3); + INTER_MARGE = b.comment("0.5 (P2.5) interaction-bloc : marge (blocs) de portée et de face cachée, en plus du déplacement du dernier tick.", + "Signale : clic sur de l'air (AirPlace), face vue de derrière, impact hors de la face d'un bloc plein, portée de bloc.") + .defineInRange("interactionBlocMarge", 0.5, 0.0, 3.0); + INTER_SERIE = b.comment("Interaction-bloc : anomalies parmi les 10 dernières interactions (60 s) avant de compter.") + .defineInRange("interactionBlocSerieMin", 3, 1, 10); b.pop(); b.comment("0.5 : diagnostics (journal seulement, jamais de sanction).").push("diagnostic"); @@ -476,6 +482,8 @@ public final class GardeSpec { c.fastPlaceSerie = FAST_PLACE_SERIE.get(); c.fastPlaceRegularite = FAST_PLACE_REGULARITE.get(); c.fastPlaceIntervalleMaxTicks = FAST_PLACE_INTERVALLE.get(); + c.interactionBlocMarge = INTER_MARGE.get(); + c.interactionBlocSerieMin = INTER_SERIE.get(); c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get(); c.setbackSolSiPasDePosition = SETBACK_SOL.get(); c.graceReculTicks = GRACE_RECUL.get(); diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index f39f210..e6c4698 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -35,7 +35,9 @@ public enum Controle { /** 0.5 (P2.3) : blocs cassés en série avant la fin de leur temps de casse (FastBreak, la marge vanilla de 30 %). */ FAST_BREAK("fast-break"), /** 0.5 (P2.4) : poses de blocs à chaque tick avec une régularité de machine (FastPlace). */ - FAST_PLACE("fast-place"); + FAST_PLACE("fast-place"), + /** 0.5 (P2.5) : clic sur un bloc impossible pour le rayon vanilla (AirPlace, face cachée, portée, impact forgé). */ + INTERACTION_BLOC("interaction-bloc"); private final String id; @@ -64,7 +66,7 @@ public enum Controle { case COUPS_HORS_BOITE, KILLAURA_ANGLE, KILLAURA_CIBLES, CADENCE -> 1; // 0.5 : nouveaux contrôles P1 au plafond « faible » tant qu'ils n'ont pas été validés en jeu. case TIMER, ROTATION, ATTAQUE_IMPOSSIBLE, VEHICULE_VITESSE, VEHICULE_VOL, ELYTRES, VELOCITE, STEP, CRITICALS, ANTI_FAIM, - NO_SLOW, FAST_BREAK, FAST_PLACE -> 2; // 0.5 (P2) : idem + NO_SLOW, FAST_BREAK, FAST_PLACE, INTERACTION_BLOC -> 2; // 0.5 (P2) : idem }; } diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index fb5a949..ea8b4ca 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -200,6 +200,10 @@ public final class GardeConfig { public double fastPlaceRegularite = 0.9; /** FastPlace : cet intervalle commun (ticks) au plus ; vanilla au clic maintenu : 4. */ public int fastPlaceIntervalleMaxTicks = 1; + /** Interaction de bloc : marge (blocs) de portée et de face, en plus du déplacement du dernier tick. */ + public double interactionBlocMarge = 0.5; + /** Interaction de bloc : anomalies parmi les 10 dernières interactions (60 s) avant de compter. */ + public int interactionBlocSerieMin = 3; // --- 0.5 (P1.13, section [diagnostic]) : journal seulement, jamais de sanction --- /** Journaliser les ABORT de casse de bloc sans START correspondant (« Mismatch in destroy block pos »). */ diff --git a/src/main/java/com/gastinelgarde/core/InteractionBloc.java b/src/main/java/com/gastinelgarde/core/InteractionBloc.java new file mode 100644 index 0000000..404809b --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/InteractionBloc.java @@ -0,0 +1,97 @@ +package com.gastinelgarde.core; + +/** + * 0.5 (P2.5) : interaction avec un bloc impossible pour le lancer de rayon du client vanilla (AirPlace, Scaffold + * simple, casse ou pose à travers un bloc, portée de bloc). Le client vanilla n'envoie un clic sur un bloc que si son + * rayon (depuis l'œil, longueur = attribut {@code block_interaction_range}, 4,5 en survie) touche la forme de contour + * du bloc, sur la face par laquelle il entre. Le serveur (handleUseItemOn, vérifié dans les sources NeoForge + * 21.1.234) n'exige que : œil à moins de portée + 1 de la boîte du bloc, impact à moins d'un bloc du centre. + * + * Anomalies (une seule rapportée, la première) : + *
    + *
  • {@code bloc-vide} : le bloc cliqué est de l'air (AirPlace : le rayon vanilla ne touche jamais l'air) ;
  • + *
  • {@code face-cachee} : l'œil est derrière le plan de la face cliquée (plus de marge) : le rayon n'a pas pu y + * entrer ;
  • + *
  • {@code hors-portee} : impact (ou boîte du bloc, sans impact) à plus de portée + marge de l'œil ;
  • + *
  • {@code impact-hors-face} : bloc plein, impact pas sur le plan de la face cliquée (vecteur forgé).
  • + *
+ * La marge ({@link GardeConfig#interactionBlocMarge} 0,5) s'ajoute au déplacement du dernier tick : le rayon du client + * part de l'œil interpolé entre deux ticks. Au-delà de portée + 1, vanilla refuse déjà : si l'adaptateur voit plus + * loin, un mod a transformé les coordonnées (vaisseau Sable) et rien n'est mesuré. + */ +public final class InteractionBloc { + + public static final int SERIE = 10; + public static final long FENETRE_MS = 60_000; + /** Tolérance (blocs) de l'impact sur le plan d'une face de bloc plein (flottants du paquet). */ + public static final double TOLERANCE_PLAN = 0.01; + + private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS); + private int dernierCompte; + + /** + * @param oeil œil du joueur (x, y, z) + * @param boite boîte de contour du bloc en coordonnées absolues (minX, minY, minZ, maxX, maxY, maxZ) ; pour un bloc + * sans contour, le cube unité + * @param face face cliquée, ordre de {@code Direction.get3DDataValue} : 0 bas, 1 haut, 2 nord (−z), 3 sud (+z), + * 4 ouest (−x), 5 est (+x) ; -1 = inconnue + * @param impact point d'impact envoyé par le client, null s'il n'y en a pas (début de casse) + * @param air le bloc cliqué est de l'air + * @param plein le bloc a une forme de cube plein + * @param portee portée d'interaction de bloc du joueur (attribut) + * @param marge marge (blocs), déplacement du dernier tick compris + * @return la première anomalie, null si aucune ou si les coordonnées ne sont pas mesurables + */ + public static String anomalie(double[] oeil, double[] boite, int face, double[] impact, boolean air, boolean plein, + double portee, double marge) { + double dBoite = Math.sqrt(distanceCarreeBoite(oeil, boite)); + if (dBoite > portee + 1.0 + 1e-3) return null; // vanilla refuse ou un mod a transformé les coordonnées + if (air) return "bloc-vide"; + if (face >= 0 && face <= 5) { + double[] plan = {boite[1], boite[4], boite[2], boite[5], boite[0], boite[3]}; + int axe = face <= 1 ? 1 : face <= 3 ? 2 : 0; + boolean positive = face == 1 || face == 3 || face == 5; + double ecart = positive ? oeil[axe] - plan[face] : plan[face] - oeil[axe]; + if (ecart < -marge) return "face-cachee"; + if (impact != null && plein) { + boolean horsPlan = Math.abs(impact[axe] - plan[face]) > TOLERANCE_PLAN; + boolean horsBoite = false; + for (int a = 0; a < 3; a++) { + if (a == axe) continue; + if (impact[a] < boite[a] - TOLERANCE_PLAN || impact[a] > boite[a + 3] + TOLERANCE_PLAN) horsBoite = true; + } + if (horsPlan || horsBoite) return "impact-hors-face"; + } + } + double d = impact != null ? Math.sqrt(carre(impact[0] - oeil[0]) + carre(impact[1] - oeil[1]) + carre(impact[2] - oeil[2])) + : dBoite; + if (d > portee + marge) return "hors-portee"; + return null; + } + + /** Une interaction mesurée ; {@code anomalie} null = normale. @return points d'infraction */ + public double enregistrer(long nowMs, String anomalie, GardeConfig cfg) { + dernierCompte = serie.ajouter(nowMs, anomalie != null); + if (anomalie == null || dernierCompte < Math.max(1, cfg.interactionBlocSerieMin)) return 0; + return 2.0; + } + + public int dernierCompte() { + return dernierCompte; + } + + public void vider() { + serie.vider(); + } + + static double distanceCarreeBoite(double[] p, double[] b) { + double dx = Math.max(0, Math.max(b[0] - p[0], p[0] - b[3])); + double dy = Math.max(0, Math.max(b[1] - p[1], p[1] - b[4])); + double dz = Math.max(0, Math.max(b[2] - p[2], p[2] - b[5])); + return dx * dx + dy * dy + dz * dz; + } + + private static double carre(double v) { + return v * v; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index c9169cf..293d9d8 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -521,6 +521,26 @@ public final class Moteur { return v; } + /** + * Clic sur un bloc (RightClickBlock, ou début de casse sans impact) : interaction-bloc. Voir + * {@link InteractionBloc#anomalie} pour les paramètres géométriques. + */ + 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) { + 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); + 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); + 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)); + return v; + } + /** * L'exemption tient-elle à un état dont la fin arrive en retard côté serveur (élytres, riptide, véhicule, vol, * contraption, lévitation, chute lente, mode de jeu) ? Une grâce seule (téléportation, recul) : non. diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index 9759486..1be6d9f 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -71,6 +71,8 @@ public final class Suivi { public final FastBreak fastBreak = new FastBreak(); /** 0.5 (P2.4) : fast-place. */ public final FastPlace fastPlace = new FastPlace(); + /** 0.5 (P2.5) : interaction-bloc. */ + public final InteractionBloc interactionBloc = new InteractionBloc(); /** 0.5 (P1.6) : déploiements d'élytres répétés. */ public final DeploiementsElytres deploiements = new DeploiementsElytres(); /** 0.5 (P1.13) : diagnostic des actions de casse de bloc. */ diff --git a/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java b/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java new file mode 100644 index 0000000..46f4d93 --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/InteractionBlocP2Test.java @@ -0,0 +1,98 @@ +package com.gastinelgarde.core; + +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.UUID; +import org.junit.jupiter.api.Test; + +/** 0.5, P2.5 : interaction-bloc (AirPlace, face cachée, portée, impact forgé). */ +class InteractionBlocP2Test { + + private final GardeConfig cfg = new GardeConfig(); + private final UUID joueur = UUID.randomUUID(); + + /** Bloc plein en (0, 64, 0). */ + private static final double[] CUBE = {0, 64, 0, 1, 65, 1}; + /** Dalle du bas en (0, 64, 0). */ + private static final double[] DALLE = {0, 64, 0, 1, 64.5, 1}; + private static final int BAS = 0, HAUT = 1, NORD = 2, SUD = 3, OUEST = 4, EST = 5; + + private static String a(double[] oeil, double[] boite, int face, double[] impact, boolean air, boolean plein) { + return InteractionBloc.anomalie(oeil, boite, face, impact, air, plein, 4.5, 0.5); + } + + @Test + void observeParDefaut() { + assertEquals(Mode.OBSERVE, cfg.mode(Controle.INTERACTION_BLOC)); + assertEquals(Controle.INTERACTION_BLOC, Controle.parse("interaction-bloc")); + } + + @Test + void clicsVanillaSansAnomalie() { + // Debout sur le bloc voisin, regard vers la face du haut ; face est vue de l'est ; dalle par-dessus. + assertNull(a(new double[] {1.5, 66.62, 0.5}, CUBE, HAUT, new double[] {0.7, 65, 0.5}, false, true)); + assertNull(a(new double[] {3.0, 65.62, 0.5}, CUBE, EST, new double[] {1, 64.6, 0.5}, false, true)); + assertNull(a(new double[] {0.5, 64.3 + 1.62, 2.0}, DALLE, HAUT, new double[] {0.5, 64.5, 0.9}, false, false)); + // Scaffold vanilla (pont vers l'avant en reculant) : face nord du bloc sous soi, œil juste derrière le plan. + assertNull(a(new double[] {0.5, 66.62, -0.2}, CUBE, NORD, new double[] {0.5, 64.8, 0}, false, true)); + // Début de casse sans impact, à 4 blocs. + assertNull(a(new double[] {0.5, 66.62, 5.0}, CUBE, SUD, null, false, true)); + } + + @Test + void anomalies() { + assertEquals("bloc-vide", a(new double[] {0.5, 66.62, 2}, CUBE, HAUT, new double[] {0.5, 65, 0.5}, true, false)); + // Face du bas cliquée depuis au-dessus du bloc (à travers le bloc). + assertEquals("face-cachee", a(new double[] {0.5, 66.62, 2}, CUBE, BAS, new double[] {0.5, 64, 0.5}, false, true)); + // Face ouest cliquée depuis l'est, à 2 blocs derrière le plan. + assertEquals("face-cachee", a(new double[] {3.0, 65.62, 0.5}, CUBE, OUEST, new double[] {0, 64.5, 0.5}, false, true)); + // Impact au centre du bloc (vecteur forgé), face haute. + assertEquals("impact-hors-face", a(new double[] {0.5, 66.62, 2}, CUBE, HAUT, new double[] {0.5, 64.5, 0.5}, false, true)); + // 5,2 blocs : au-delà de 4,5 + 0,5, en deçà de la limite vanilla (portée + 1). + assertEquals("hors-portee", a(new double[] {0.5, 64.5, 6.2}, CUBE, SUD, new double[] {0.5, 64.5, 1}, false, true)); + } + + @Test + void coordonneesTransformeesNonMesurees() { + // Au-delà de portée + 1, vanilla refuse le paquet : si l'événement arrive quand même, un mod (Sable) a + // transformé les coordonnées : rien n'est mesuré, même un bloc d'air. + assertNull(a(new double[] {5000, 100, 5000}, CUBE, BAS, new double[] {0.5, 64, 0.5}, true, true)); + } + + @Test + void margeDuDeplacement() { + // Œil 1 bloc derrière le plan : anomalie avec la marge seule, pas après un déplacement de 0,6 bloc. + double[] oeil = {1.0, 66.62, 0.5}; + double[] impact = {0, 64.5, 0.5}; + assertEquals(null, InteractionBloc.anomalie(oeil, CUBE, OUEST, impact, false, true, 4.5, 1.1)); + assertEquals("face-cachee", InteractionBloc.anomalie(oeil, CUBE, OUEST, impact, false, true, 4.5, 0.5)); + } + + private double serie(Moteur m, EtatJoueur etat, int n, boolean air) { + double pts = 0; + for (int i = 0; i < n; i++) { + for (Verdict v : m.interactionBloc(joueur, i * 500L, etat, new double[] {0.5, 66.62, 2}, CUBE, HAUT, + new double[] {0.5, 65, 0.5}, air, true, 4.5, 0)) { + if (v.controle() == Controle.INTERACTION_BLOC) pts += v.points(); + } + } + return pts; + } + + @Test + void serieExigee() { + assertEquals(0, serie(new Moteur(cfg), EtatJoueur.normal(), 2, true), 1e-9); + assertTrue(serie(new Moteur(cfg), EtatJoueur.normal(), 3, true) > 0); + assertEquals(0, serie(new Moteur(cfg), EtatJoueur.normal(), 50, false), 1e-9); + } + + @Test + void exemptions() { + for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(), + EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().pocheContraption(true).build()}) { + assertEquals(0, serie(new Moteur(cfg), e, 10, true), 1e-9, e.toString()); + } + } +}