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 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Sonnet 5.5 a révisé 2026-10-24 00:59:31 +02:00
1 Parent 2777f75a8b
révision ba37380d8e
5 fichiers modifiés
+50 -3

Aucun fichier ne correspond à votre recherche

+1 -1
Voir le fichier
@@ -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);
+5 -2
Voir le fichier
@@ -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);
+11
Voir le fichier
@@ -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;
}
+10
Voir le fichier
@@ -527,10 +527,20 @@ public final class Moteur {
*/
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) {
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<Verdict> 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);
+23
Voir le fichier
@@ -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);
}
}