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 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Sonnet 5.5 a révisé 2026-10-24 00:55:42 +02:00
1 Parent fad4da8f7c
révision 5397ea8c6e
9 fichiers modifiés
+283 -5

Aucun fichier ne correspond à votre recherche

+38 -1
Voir le fichier
@@ -425,9 +425,46 @@ public final class Garde {
} }
} }
/** 0.5 (P2.3) : START de casse accepté : début de la mesure fast-break. */ /** 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; if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return;
MOTEUR.debutCasse(p.getUUID(), p.server.getTickCount(), pos.getX(), pos.getY(), pos.getZ()); 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<Verdict> 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<Verdict> 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<Verdict> 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);
} }
/** /**
+11 -1
Voir le fichier
@@ -132,7 +132,7 @@ public final class GardeEvents {
var a = event.getAction(); var a = event.getAction();
// 0.5 (P2.3) : début de la mesure fast-break (START accepté par les autres mods). // 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()) { 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, 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, 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); 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. */ /** 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) @SubscribeEvent(priority = EventPriority.LOWEST)
public static void onPose(net.neoforged.neoforge.event.level.BlockEvent.EntityPlaceEvent event) { public static void onPose(net.neoforged.neoforge.event.level.BlockEvent.EntityPlaceEvent event) {
+9 -1
Voir le fichier
@@ -33,7 +33,8 @@ public final class GardeSpec {
private static final ModConfigSpec.DoubleValue FAST_BREAK_FACTEUR; 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_BREAK_TICKS_MIN, FAST_BREAK_SERIE;
private static final ModConfigSpec.IntValue FAST_PLACE_SERIE, FAST_PLACE_INTERVALLE; 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.DoubleValue ANGLE_MAX;
private static final ModConfigSpec.IntValue CIBLES_MAX; private static final ModConfigSpec.IntValue CIBLES_MAX;
@@ -296,6 +297,11 @@ public final class GardeSpec {
.defineInRange("fastPlaceRegularite", 0.9, 0.5, 1.0); .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.") 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); .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.pop();
b.comment("0.5 : diagnostics (journal seulement, jamais de sanction).").push("diagnostic"); 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.fastPlaceSerie = FAST_PLACE_SERIE.get();
c.fastPlaceRegularite = FAST_PLACE_REGULARITE.get(); c.fastPlaceRegularite = FAST_PLACE_REGULARITE.get();
c.fastPlaceIntervalleMaxTicks = FAST_PLACE_INTERVALLE.get(); c.fastPlaceIntervalleMaxTicks = FAST_PLACE_INTERVALLE.get();
c.interactionBlocMarge = INTER_MARGE.get();
c.interactionBlocSerieMin = INTER_SERIE.get();
c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get(); c.graceApresExpulsionTicks = GRACE_APRES_EXPULSION.get();
c.setbackSolSiPasDePosition = SETBACK_SOL.get(); c.setbackSolSiPasDePosition = SETBACK_SOL.get();
c.graceReculTicks = GRACE_RECUL.get(); c.graceReculTicks = GRACE_RECUL.get();
+4 -2
Voir le fichier
@@ -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 %). */ /** 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"), FAST_BREAK("fast-break"),
/** 0.5 (P2.4) : poses de blocs à chaque tick avec une régularité de machine (FastPlace). */ /** 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; private final String id;
@@ -64,7 +66,7 @@ public enum Controle {
case COUPS_HORS_BOITE, KILLAURA_ANGLE, KILLAURA_CIBLES, CADENCE -> 1; 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. // 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, 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
}; };
} }
+4
Voir le fichier
@@ -200,6 +200,10 @@ public final class GardeConfig {
public double fastPlaceRegularite = 0.9; public double fastPlaceRegularite = 0.9;
/** FastPlace : cet intervalle commun (ticks) au plus ; vanilla au clic maintenu : 4. */ /** FastPlace : cet intervalle commun (ticks) au plus ; vanilla au clic maintenu : 4. */
public int fastPlaceIntervalleMaxTicks = 1; 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 --- // --- 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 »). */ /** Journaliser les ABORT de casse de bloc sans START correspondant (« Mismatch in destroy block pos »). */
+97
Voir le fichier
@@ -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) :
* <ul>
* <li>{@code bloc-vide} : le bloc cliqué est de l'air (AirPlace : le rayon vanilla ne touche jamais l'air) ;</li>
* <li>{@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 ;</li>
* <li>{@code hors-portee} : impact (ou boîte du bloc, sans impact) à plus de portée + marge de l'œil ;</li>
* <li>{@code impact-hors-face} : bloc plein, impact pas sur le plan de la face cliquée (vecteur forgé).</li>
* </ul>
* 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;
}
}
+20
Voir le fichier
@@ -521,6 +521,26 @@ public final class Moteur {
return v; 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<Verdict> 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<Verdict> 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, * 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. * contraption, lévitation, chute lente, mode de jeu) ? Une grâce seule (téléportation, recul) : non.
+2
Voir le fichier
@@ -71,6 +71,8 @@ public final class Suivi {
public final FastBreak fastBreak = new FastBreak(); public final FastBreak fastBreak = new FastBreak();
/** 0.5 (P2.4) : fast-place. */ /** 0.5 (P2.4) : fast-place. */
public final FastPlace fastPlace = new FastPlace(); 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. */ /** 0.5 (P1.6) : déploiements d'élytres répétés. */
public final DeploiementsElytres deploiements = new DeploiementsElytres(); public final DeploiementsElytres deploiements = new DeploiementsElytres();
/** 0.5 (P1.13) : diagnostic des actions de casse de bloc. */ /** 0.5 (P1.13) : diagnostic des actions de casse de bloc. */
+98
Voir le fichier
@@ -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());
}
}
}