P2.5 (revues 2 et 3) : doublons d'interaction-bloc, decision gardee

- Seconde revue de securite : le dedoublonnage par (instant, bloc) laissait
  passer tout second evenement du meme tick sur le meme bloc.
- Desormais la verification (InteractionBloc.anomalie) tourne sur chaque
  evenement. Seul le comptage des points est saute, et seulement pour la main
  secondaire qui suit la principale au meme instant, sur le meme bloc, meme
  face, meme impact, meme anomalie, une fois par instant (cle incluant la
  main). Elle reprend alors les verdicts memorises de la principale : meme
  decision d'annulation (event.setCanceled) ; un doublon n'est jamais lu comme
  autorise. Tout autre evenement (meme main repetee, autre face, autre impact,
  troisieme evenement) est evalue et compte normalement.
- Moteur.interactionBloc prend la main (0 principale, 1 secondaire) ; Garde et
  GardeEvents la transmettent.
- Autres controles P2 : aucun n'utilise ce mecanisme (fast-place regroupe les
  poses d'un meme tick pour mesurer la regularite, sans sauter de verification).
- Tests (InteractionBlocP2Test, 5 au lieu d'un) : main secondaire seule
  mesuree ; doublon vanilla compte une fois avec la meme decision ; meme main
  repetee evaluee ; autre face / impact forge evalues ; rafale sur le meme bloc
  detectee.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Cette révision appartient à :
gastineltetClaude Sonnet 5.5 a révisé 2026-10-24 01:02:57 +02:00
1 Parent ba37380d8e
révision 4d21404bcd
5 fichiers modifiés
+133 -35

Aucun fichier ne correspond à votre recherche

+5 -5
Voir le fichier
@@ -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<Verdict> v = verdictsInteraction(p, pos, face, null);
List<Verdict> 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<Verdict> v = verdictsInteraction(p, pos, face, impact);
List<Verdict> 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<Verdict> 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);
+4 -2
Voir le fichier
@@ -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);
}
}
+40 -5
Voir le fichier
@@ -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<Verdict> 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<Verdict> 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<Verdict> 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() {
+15 -6
Voir le fichier
@@ -527,27 +527,36 @@ 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);
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<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) {
public List<Verdict> 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<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));
s.interactionBloc.memoriser(nowMs, cleBloc, main, face, impact, a, v);
return v;
}
+69 -17
Voir le fichier
@@ -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<Verdict> 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<Verdict> 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<Verdict> principale = clic(m, 1000L, 7L, 0, HAUT, IMPACT, true);
List<Verdict> 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");
}
}