From c2a0d5403dcf18bc0513c27aea35c706d76122cc Mon Sep 17 00:00:00 2001 From: gastinelt <264859180+gastinelt@users.noreply.github.com> Date: Sun, 25 Oct 2026 21:59:10 +0100 Subject: [PATCH] 0.6.1-dev : correctifs revue M1-M4 (setback unique par tick, VL de la cause remis a zero, blocs fantomes, exemption nuker configurable) Co-Authored-By: Claude Opus 5.5 --- gradle.properties | 2 +- src/main/java/com/gastinelgarde/Cablage.java | 10 +- src/main/java/com/gastinelgarde/Garde.java | 25 ++- .../java/com/gastinelgarde/GardeSpec.java | 11 ++ .../com/gastinelgarde/core/GardeConfig.java | 7 + .../java/com/gastinelgarde/core/Moteur.java | 60 +++++++ .../java/com/gastinelgarde/core/Suivi.java | 32 ++++ .../java/com/gastinelgarde/CablageTest.java | 19 +++ .../com/gastinelgarde/core/Revue061Test.java | 146 ++++++++++++++++++ 9 files changed, 308 insertions(+), 4 deletions(-) create mode 100644 src/test/java/com/gastinelgarde/core/Revue061Test.java diff --git a/gradle.properties b/gradle.properties index 1220147..eae6c40 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,7 +1,7 @@ org.gradle.jvmargs=-Xmx2G org.gradle.parallel=true -mod_version=0.6.0-dev +mod_version=0.6.1-dev mod_group_id=com.gastinelgarde mod_id=gastinelgarde diff --git a/src/main/java/com/gastinelgarde/Cablage.java b/src/main/java/com/gastinelgarde/Cablage.java index c5ad6e3..d2e4920 100644 --- a/src/main/java/com/gastinelgarde/Cablage.java +++ b/src/main/java/com/gastinelgarde/Cablage.java @@ -225,19 +225,25 @@ final class Cablage { p.journal(p.nom() + " EXPULSE (" + motif + ")"); p.deconnecter("Expulsé par l'anti-triche (" + raison + ")."); } else if (s == Sanction.SETBACK) { + if (moteur.setbackDejaApplique(p.id(), p.tick() * 50L)) { + // 0.6.1 (revue M1) : même paquet, second contrôle : pas de second retour ni de second compte. + moteur.apresSetbackDuMemeTick(p.id(), verdicts); + p.journal(p.nom() + " SETBACK deja applique ce tick (" + motif + ") : ni second retour ni second compte"); + return; + } Suivi sv = moteur.suivi(p.id()); double[] sol; if (sv.aPositionValide() && sv.dimension().equals(p.dimension())) { p.annoncerTeleport(GraceTeleport.Origine.SETBACK); p.teleporter(sv.x(), sv.y(), sv.z(), sv.yaw(), sv.pitch()); // C2 (16/10) : le vol, la vitesse et leurs VL repartent de zéro depuis la position au sol. - moteur.apresSetback(p.id(), p.tick() * 50L); + moteur.apresSetback(p.id(), p.tick() * 50L, verdicts); p.journal(p.nom() + " SETBACK (" + motif + ")"); } else if (!sv.aPositionValide() && moteur.config().setbackSolSiPasDePosition && (sol = p.solSous()) != null) { // 0.5 (P1.2) : reconnexion en l'air (aucune position au sol connue) : retour au sol sous le joueur. p.annoncerTeleport(GraceTeleport.Origine.SETBACK); p.teleporter(sol[0], sol[1], sol[2], (float) sol[3], (float) sol[4]); - moteur.apresSetback(p.id(), p.tick() * 50L); + moteur.apresSetback(p.id(), p.tick() * 50L, verdicts); p.journal(String.format(java.util.Locale.ROOT, "%s SETBACK au sol (%s) : pas de position de retour, y=%.2f", p.nom(), motif, sol[1])); } else { diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index c78e008..ecdbef8 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -417,6 +417,8 @@ public final class Garde { * ligne de journal pour un ABORT sans START correspondant (message vanilla « Mismatch in destroy block pos »). */ public static void noterActionBloc(ServerPlayer p, boolean start, boolean abort, BlockPos pos, boolean annule) { + // 0.6.1 (revue M2) : bloc visé par un paquet de casse (pour nukerIgnorerCassesSansPaquet). + if (surThreadServeur(p)) MOTEUR.paquetCasse(p.getUUID(), pos.asLong(), p.server.getTickCount() * 50L); if (!CONFIG.diagnosticActionsBloc || !surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return; com.gastinelgarde.core.ActionsBloc a = MOTEUR.suivi(p.getUUID()).actionsBloc; if (start) { @@ -426,6 +428,22 @@ public final class Garde { if (ligne != null) ecrireJournal("DIAGNOSTIC " + p.getGameProfile().getName() + " casse de bloc : " + ligne); } } + /** + * 0.6.1 (revue M3) : un bloc change (casse ou pose) : noté pour chaque joueur à moins de 16 blocs, dont l'auteur, car + * le client d'un voisin peut encore voir l'ancien bloc (lag) et cliquer dessus. + */ + private static void changementProche(ServerPlayer auteur, BlockPos pos) { + long cle = pos.asLong(); + long ms = auteur.server.getTickCount() * 50L; + MOTEUR.changementBloc(auteur.getUUID(), cle, ms); + if (!(auteur.level() instanceof net.minecraft.server.level.ServerLevel niveau)) return; + for (ServerPlayer autre : niveau.players()) { + if (autre != auteur && autre.distanceToSqr(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5) <= 256) { + MOTEUR.changementBloc(autre.getUUID(), cle, ms); + } + } + } + /** 0.5 (P2.3) : START de casse accepté : début de la mesure fast-break. */ public static void noterDebutCasse(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face) { if (!surThreadServeur(p) || MOTEUR.estExpulse(p.getUUID())) return; @@ -450,6 +468,8 @@ public final class Garde { List v = verdictsInteraction(p, pos, face, impact, mainPrincipale ? 0 : 1); Sanction s = traiter(p, v); if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v); + // 0.6.1 (revue M3) : case où ce clic pose un bloc ; si la pose est refusée, le client garde un bloc fantôme. + if (face != null) MOTEUR.changementBloc(p.getUUID(), pos.relative(face).asLong(), p.server.getTickCount() * 50L); boolean annulerScaffold = poseScaffold(p, pos, face, impact, mainPrincipale); return Cablage.sanctionDeMouvement(s) || annulerScaffold; } @@ -583,6 +603,7 @@ public final class Garde { */ public static boolean noterCasse(ServerPlayer p, BlockPos pos, BlockState state) { if (!surThreadServeur(p)) return false; + changementProche(p, pos); // 0.6.1 (revue M3) : avant tout retour, pour tous les joueurs proches if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, casse annulée (C4) if (estExempteManuellement(p.getUUID())) return false; int tick = p.server.getTickCount(); @@ -591,7 +612,8 @@ public final class Garde { traiter(p, MOTEUR.casseXray(p.getUUID(), tick * 50L, etat(p, false), pos.getY(), rare, rare && expose(p, pos))); } boolean annulerNuker = false; - if (CONFIG.mode(Controle.NUKER) != Mode.OFF) { // 0.5 (P3.3) + if (CONFIG.mode(Controle.NUKER) != Mode.OFF // 0.5 (P3.3) ; 0.6.1 (M2) : casse en chaîne d'un mod ignorée si réglé + && !MOTEUR.casseNukerSansPaquet(p.getUUID(), pos.asLong(), tick * 50L)) { List vn = MOTEUR.casseNuker(p.getUUID(), tick * 50L, tick, etat(p, true)); Sanction sn = traiter(p, vn); if (sn == Sanction.EXPULSION) { @@ -647,6 +669,7 @@ public final class Garde { /** 0.5 (P2.4) : bloc posé par ce joueur. Vrai si la pose doit être annulée (ENFORCE, palier SETBACK ou plus). */ public static boolean noterPose(ServerPlayer p, BlockPos pos) { if (!surThreadServeur(p)) return false; + changementProche(p, pos); // 0.6.1 (revue M3) if (MOTEUR.estExpulse(p.getUUID())) return true; // 0.5 (P3, revue) : expulsion en cours, pose annulée (C4) if (estExempteManuellement(p.getUUID())) return false; int tick = p.server.getTickCount(); diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index f6b2b90..5143800 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -36,6 +36,8 @@ public final class GardeSpec { 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, INTER_MARGE; + private static final ModConfigSpec.IntValue INTER_GRACE; + private static final ModConfigSpec.BooleanValue NUKER_SANS_PAQUET; private static final ModConfigSpec.IntValue INTER_SERIE, TOTEM_ECHANT, TOTEM_ECART, TOTEM_REG_MAX; // 0.5 (P3) private static final ModConfigSpec.IntValue NUKER_MAX, NUKER_SERIE, CRISTAL_DELAI, CRISTAL_SERIE, TOWER_INTERVALLE, TOWER_SERIE, @@ -322,6 +324,9 @@ public final class GardeSpec { .defineInRange("autoTotemRegulierMaxMs", 300, 50, 2000); INTER_SERIE = b.comment("Interaction-bloc : anomalies parmi les 10 dernières interactions (60 s) avant de compter.") .defineInRange("interactionBlocSerieMin", 3, 1, 10); + INTER_GRACE = b.comment("0.6.1 (revue M3) interaction-bloc : un clic sur un bloc devenu de l'air depuis moins de ce délai (ms)", + "(casse, pose ou pose refusée : bloc fantôme côté client) ne compte pas comme « bloc-vide ».") + .defineInRange("interactionBlocGraceChangementMs", 500, 0, 5000); b.pop(); b.comment("0.5 (P3) : contrôles lourds. Nouveaux contrôles en OBSERVE par défaut, valeurs prudentes.").push("p3"); @@ -331,6 +336,10 @@ public final class GardeSpec { .defineInRange("nukerBlocsParTickMax", 3, 1, 64); NUKER_SERIE = b.comment("Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter.") .defineInRange("nukerSerieMin", 3, 1, 20); + NUKER_SANS_PAQUET = b.comment("0.6.1 (revue M2) nuker : true = ne compter que les casses visées par un paquet de casse du joueur", + "dans le même tick (ignore les blocs cassés en chaîne par un mod d'abattage d'arbres ou de minage de filon).", + "false par défaut (aucun mod de ce genre sur le serveur). Un nuker de client triche envoie un paquet par bloc : il reste vu.") + .define("nukerIgnorerCassesSansPaquet", false); CRISTAL_DELAI = b.comment("0.5 (P3.1) auto-cristal : âge (ticks serveur) d'un cristal de l'End frappé sous lequel le coup est suspect.", "2 = frappé dans le tick de sa pose ou le suivant. Cristaux d'âge inconnu (rechargés, posés avant) non mesurés.", "Risque de faux positif élevé (PvP cristal rapide, paquets groupés) : longue observation avant tout ENFORCE.") @@ -592,11 +601,13 @@ public final class GardeSpec { c.fastPlaceIntervalleMaxTicks = FAST_PLACE_INTERVALLE.get(); c.interactionBlocMarge = INTER_MARGE.get(); c.interactionBlocSerieMin = INTER_SERIE.get(); + c.interactionBlocGraceChangementMs = INTER_GRACE.get(); c.autoTotemEchantillons = TOTEM_ECHANT.get(); c.autoTotemEcartTypeMinMs = TOTEM_ECART.get(); c.autoTotemRegulierMaxMs = TOTEM_REG_MAX.get(); c.nukerBlocsParTickMax = NUKER_MAX.get(); c.nukerSerieMin = NUKER_SERIE.get(); + c.nukerIgnorerCassesSansPaquet = NUKER_SANS_PAQUET.get(); c.cristalDelaiMinTicks = CRISTAL_DELAI.get(); c.cristalSerieMin = CRISTAL_SERIE.get(); c.towerIntervalleMinTicks = TOWER_INTERVALLE.get(); diff --git a/src/main/java/com/gastinelgarde/core/GardeConfig.java b/src/main/java/com/gastinelgarde/core/GardeConfig.java index f32ccb4..b8d32cc 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -204,6 +204,8 @@ public final class GardeConfig { 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.6.1 (revue M3) : « bloc-vide » non compté si ce bloc a changé (casse, pose, clic de pose) depuis ce délai (ms). */ + public int interactionBlocGraceChangementMs = 500; /** Auto-totem régulier : délais (éclatement → totem en main) examinés. */ public int autoTotemEchantillons = 5; /** Auto-totem régulier : écart type (ms) sous lequel ces délais sont ceux d'une machine. */ @@ -230,6 +232,11 @@ public final class GardeConfig { public int nukerBlocsParTickMax = 3; /** Nuker : ticks suspects parmi les 20 derniers ticks de casse (60 s) avant de compter. */ public int nukerSerieMin = 3; + /** + * 0.6.1 (revue M2) : vrai = le nuker ne compte que les casses visées par un paquet de casse du joueur dans le même + * tick ; les blocs cassés par un mod d'abattage / de minage de filon au nom du joueur sont ignorés. Faux par défaut. + */ + public boolean nukerIgnorerCassesSansPaquet = false; /** Auto-cristal : âge (ticks serveur) d'un cristal de l'End frappé sous lequel le coup est suspect (2 : même tick ou suivant). */ public int cristalDelaiMinTicks = 2; /** Auto-cristal : coups suspects parmi les 10 derniers coups sur un cristal récent (60 s) avant de compter. */ diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index 1e41618..69f2933 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -531,6 +531,28 @@ public final class Moteur { return v; } + /** 0.6.1 (revue M2) : paquet de casse (START/STOP/ABORT) du joueur sur ce bloc ({@code BlockPos.asLong}). */ + public void paquetCasse(UUID joueur, long cleBloc, long nowMs) { + if (expulses.contains(joueur)) return; + suivi(joueur).paquetsCasse.noter(cleBloc, nowMs); + } + + /** + * 0.6.1 (revue M2) : cette casse est-elle hors du nuker ? Vrai seulement si {@code nukerIgnorerCassesSansPaquet} est + * activé et qu'aucun paquet de casse du joueur n'a visé ce bloc dans le même tick (casse en chaîne d'un mod). + */ + public boolean casseNukerSansPaquet(UUID joueur, long cleBloc, long nowMs) { + if (!cfg.nukerIgnorerCassesSansPaquet) return false; + Suivi s = suivis.get(joueur); + return s == null || !s.paquetsCasse.contient(cleBloc, nowMs, 0); + } + + /** 0.6.1 (revue M3) : un bloc proche de ce joueur vient de changer (casse, pose, cible d'un clic de pose). */ + public void changementBloc(UUID joueur, long cleBloc, long nowMs) { + if (expulses.contains(joueur)) return; + suivi(joueur).changementsBloc.noter(cleBloc, nowMs); + } + /** * 0.5 (P3.3) : bloc cassé par le joueur, pour le nuker (plusieurs blocs dans le même tick serveur). Exemptions de la * famille MONDE (créatif, spectateur, contraption, vaisseau, gel) ; TPS bas : pas de mesure (paquets groupés). @@ -813,6 +835,12 @@ public final class Moteur { 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); + // 0.6.1 (revue M3) : bloc fantôme (le client voit encore un bloc que le serveur vient de casser, ou une pose + // refusée) : « bloc-vide » n'est pas compté si ce bloc a changé il y a peu. + if ("bloc-vide".equals(a) && cleBloc != Long.MIN_VALUE + && s.changementsBloc.contient(cleBloc, nowMs, Math.max(0, cfg.interactionBlocGraceChangementMs))) { + a = null; + } // 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) @@ -1003,13 +1031,45 @@ public final class Moteur { * paquet suivant sert de référence) et leurs VL sont remis à zéro ; le setback est compté pour l'escalade (C5). */ public void apresSetback(UUID joueur, long nowMs) { + apresSetback(joueur, nowMs, List.of()); + } + + /** + * 0.6.1 (revue M4) : idem, et le VL de chaque contrôle qui a demandé ce setback (verdict applicable ≥ SETBACK) est + * aussi remis à zéro. Avant, step, no-slow ou jesus restaient au-dessus du seuil et redonnaient un setback à chaque + * paquet, jusqu'à l'expulsion. Le setback est noté pour l'escalade et pour {@link #setbackDejaApplique} (M1). + */ + public void apresSetback(UUID joueur, long nowMs, List causes) { Suivi s = suivi(joueur); s.vol.vider(); s.vitesse.vider(); s.graceElytresJusquaMs = Long.MIN_VALUE; s.vl.remettreAZero(Controle.VOL); s.vl.remettreAZero(Controle.VITESSE); + remettreAZeroCauses(s, causes); s.noterSetback(nowMs); + s.dernierSetbackMs = nowMs; + } + + /** + * 0.6.1 (revue M1) : un setback a-t-il déjà été appliqué à cet instant (même tick serveur) ? Un même paquet peut + * donner SETBACK sur vol puis sur jesus/no-slow : un seul retour et un seul compte pour l'escalade. + */ + public boolean setbackDejaApplique(UUID joueur, long nowMs) { + Suivi s = suivis.get(joueur); + return s != null && s.dernierSetbackMs == nowMs; + } + + /** 0.6.1 (revue M1/M4) : second setback du même tick : seuls les VL de ses causes sont remis à zéro. */ + public void apresSetbackDuMemeTick(UUID joueur, List causes) { + remettreAZeroCauses(suivi(joueur), causes); + } + + private static void remettreAZeroCauses(Suivi s, List causes) { + if (causes == null) return; + for (Verdict v : causes) { + if (v.applicable().ordinal() >= Sanction.SETBACK.ordinal()) s.vl.remettreAZero(v.controle()); + } } /** diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index 96f4341..02dda0b 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -33,6 +33,9 @@ public final class Suivi { /** C5 (16/10) : instants des derniers setbacks (ms), du plus ancien au plus récent. */ private final java.util.ArrayDeque setbacks = new java.util.ArrayDeque<>(); + /** 0.6.1 (revue M1) : instant (ms) du dernier setback appliqué. */ + long dernierSetbackMs = Long.MIN_VALUE; + void noterSetback(long nowMs) { setbacks.addLast(nowMs); while (setbacks.size() > 32) setbacks.removeFirst(); @@ -81,6 +84,35 @@ public final class Suivi { public final Omnisprint omnisprint = new Omnisprint(); /** 0.5 (P2.10) : x-ray statistique. */ public final XrayStats xray = new XrayStats(); + /** 0.6.1 (revue M3) : blocs récemment changés (casse, pose, cible d'un clic droit) près du joueur. */ + public final PositionsRecentes changementsBloc = new PositionsRecentes(); + /** 0.6.1 (revue M2) : blocs visés par un paquet de casse du joueur (START/STOP/ABORT). */ + public final PositionsRecentes paquetsCasse = new PositionsRecentes(); + + /** 0.6.1 : petite mémoire circulaire (32 entrées) de positions de bloc ({@code BlockPos.asLong}) datées. */ + public static final class PositionsRecentes { + private static final int TAILLE = 32; + private final long[] cles = new long[TAILLE]; + private final long[] instants = new long[TAILLE]; + private int suivant; + private int remplies; + + public void noter(long cle, long nowMs) { + cles[suivant] = cle; + instants[suivant] = nowMs; + suivant = (suivant + 1) % TAILLE; + if (remplies < TAILLE) remplies++; + } + + /** Vrai si {@code cle} a été notée dans les {@code fenetreMs} qui précèdent {@code nowMs} (bornes comprises). */ + public boolean contient(long cle, long nowMs, long fenetreMs) { + for (int i = 0; i < remplies; i++) { + if (cles[i] == cle && nowMs >= instants[i] && nowMs - instants[i] <= fenetreMs) return true; + } + return false; + } + } + /** 0.5 (P3.3) : nuker. */ public final Nuker nuker = new Nuker(); /** 0.5 (P3.1) : auto-cristal. */ diff --git a/src/test/java/com/gastinelgarde/CablageTest.java b/src/test/java/com/gastinelgarde/CablageTest.java index 8ac064a..885a67a 100644 --- a/src/test/java/com/gastinelgarde/CablageTest.java +++ b/src/test/java/com/gastinelgarde/CablageTest.java @@ -313,4 +313,23 @@ class CablageTest { Cablage.CacheDetection c = new Cablage.CacheDetection(); assertFalse(c.lire(100, () -> false, 40)); } + + // --- 0.6.1 (revue M1/M4) --- + + @Test + void M1_deuxSetbacksDuMemePaquetUnSeulRetour() { + Moteur moteur = new Moteur(new GardeConfig()); + FauxJoueur p = new FauxJoueur(); + long ms = p.tick * 50L; + moteur.suivi(ID).memoriserPosition(10.5, 64.0, -3.5, 90f, 10f, MONDE); + moteur.suivi(ID).vl.ajouter(Controle.JESUS, 40, ms); + Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.VOL, Sanction.SETBACK))); + Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.JESUS, Sanction.SETBACK))); + assertEquals(1, p.compte("teleport")); + assertEquals(1, p.compte("journal Tricheur SETBACK deja applique ce tick")); + assertEquals(0.0, moteur.suivi(ID).vl.valeur(Controle.JESUS, ms), 1e-9, "M4 : VL de jesus remis à zéro"); + p.tick++; + Cablage.appliquerSanction(moteur, p, Sanction.SETBACK, List.of(verdict(Controle.JESUS, Sanction.SETBACK))); + assertEquals(2, p.compte("teleport"), "tick suivant : nouveau setback"); + } } diff --git a/src/test/java/com/gastinelgarde/core/Revue061Test.java b/src/test/java/com/gastinelgarde/core/Revue061Test.java new file mode 100644 index 0000000..c09a1f3 --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/Revue061Test.java @@ -0,0 +1,146 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.UUID; +import org.junit.jupiter.api.Test; + +/** 0.6.1 : correctifs de la revue de sécurité du 25/10 (M1 à M4), côté moteur. */ +class Revue061Test { + + private final UUID joueur = UUID.randomUUID(); + + private static Verdict v(Controle c, Sanction s) { + return new Verdict(c, Mode.ENFORCE, 5, 50, s, s, false, "", List.of()); + } + + // --- M1 : un seul setback par tick --- + + @Test + void M1_secondSetbackDuMemeTickReconnuEtNonCompte() { + Moteur m = new Moteur(new GardeConfig()); + long t = 1000 * 50L; + assertFalse(m.setbackDejaApplique(joueur, t)); + m.apresSetback(joueur, t, List.of(v(Controle.VOL, Sanction.SETBACK))); + assertTrue(m.setbackDejaApplique(joueur, t)); + m.apresSetbackDuMemeTick(joueur, List.of(v(Controle.JESUS, Sanction.SETBACK))); + assertEquals(1, m.suivi(joueur).setbacksRecents(t, 60_000), "un seul compte pour l'escalade"); + assertFalse(m.setbackDejaApplique(joueur, t + 50), "tick suivant : un nouveau setback est possible"); + } + + @Test + void M1_tricheurContinuEscaladeToujours() { + // Un setback par tick sur 4 ticks distincts : l'escalade compte bien 4 (la triche répétée reste sanctionnée). + Moteur m = new Moteur(new GardeConfig()); + for (int i = 0; i < 4; i++) m.apresSetback(joueur, (1000 + i) * 50L, List.of(v(Controle.VOL, Sanction.SETBACK))); + assertEquals(4, m.suivi(joueur).setbacksRecents(1003 * 50L, 60_000)); + } + + // --- M4 : VL de la cause remis à zéro --- + + @Test + void M4_vlDuControleCauseRemisAZero() { + Moteur m = new Moteur(new GardeConfig()); + long t = 50_000; + Suivi s = m.suivi(joueur); + s.vl.ajouter(Controle.STEP, 40, t); + s.vl.ajouter(Controle.NO_SLOW, 30, t); + s.vl.ajouter(Controle.KILLAURA_CIBLES, 7, t); + m.apresSetback(joueur, t, List.of(v(Controle.STEP, Sanction.SETBACK), v(Controle.NO_SLOW, Sanction.ALERTE))); + assertEquals(0, s.vl.valeur(Controle.STEP, t), 1e-9); + assertEquals(30, s.vl.valeur(Controle.NO_SLOW, t), 1e-9, "verdict sous SETBACK : VL gardé"); + assertEquals(7, s.vl.valeur(Controle.KILLAURA_CIBLES, t), 1e-9, "contrôle sans rapport : VL gardé"); + } + + @Test + void M4_ancienneSignatureInchangee() { + Moteur m = new Moteur(new GardeConfig()); + Suivi s = m.suivi(joueur); + s.vl.ajouter(Controle.STEP, 40, 0); + s.vl.ajouter(Controle.VOL, 40, 0); + m.apresSetback(joueur, 0); + assertEquals(40, s.vl.valeur(Controle.STEP, 0), 1e-9); + assertEquals(0, s.vl.valeur(Controle.VOL, 0), 1e-9); + } + + // --- M2 : casses en chaîne d'un mod (exemption configurable, désactivée par défaut) --- + + @Test + void M2_desactiveParDefaut() { + GardeConfig cfg = new GardeConfig(); + assertFalse(cfg.nukerIgnorerCassesSansPaquet); + assertFalse(new Moteur(cfg).casseNukerSansPaquet(joueur, 42L, 5000)); + } + + @Test + void M2_activee_cassesDUnModIgnoreesNukerAvecPaquetsVu() { + GardeConfig cfg = new GardeConfig(); + cfg.nukerIgnorerCassesSansPaquet = true; + Moteur m = new Moteur(cfg); + long t = 100 * 50L; + // Abattage d'arbre : un paquet sur la bûche du bas, 12 bûches cassées par le mod. + m.paquetCasse(joueur, 1L, t); + assertFalse(m.casseNukerSansPaquet(joueur, 1L, t), "le bloc visé par le joueur compte"); + for (long k = 2; k <= 12; k++) assertTrue(m.casseNukerSansPaquet(joueur, k, t), "bûche du mod ignorée"); + // Nuker de client : un paquet par bloc, tous comptés. + for (long k = 100; k < 110; k++) m.paquetCasse(joueur, k, t + 50); + for (long k = 100; k < 110; k++) assertFalse(m.casseNukerSansPaquet(joueur, k, t + 50)); + // Un paquet d'un tick précédent ne couvre pas la casse de ce tick. + assertTrue(m.casseNukerSansPaquet(joueur, 1L, t + 100)); + } + + // --- M3 : blocs fantômes --- + + private static final double[] CUBE = {0, 64, 0, 1, 65, 1}; + private static final double[] OEIL = {0.5, 66.62, 2}; + private static final double[] IMPACT = {0.5, 65, 0.5}; + + private double clicsAir(Moteur m, long cle, long debut, boolean changerAvant) { + double pts = 0; + for (int i = 0; i < 10; i++) { + long t = debut + i * 500L; + if (changerAvant) m.changementBloc(joueur, cle + i, t - 100); + for (Verdict x : m.interactionBloc(joueur, t, cle + i, 0, EtatJoueur.normal(), OEIL, CUBE, 1, IMPACT, + true, true, 4.5, 0)) { + if (x.controle() == Controle.INTERACTION_BLOC) pts += x.points(); + } + } + return pts; + } + + @Test + void M3_blocFantomeApresCasseNonCompte() { + assertEquals(0, clicsAir(new Moteur(new GardeConfig()), 1000, 10_000, true), 1e-9); + } + + @Test + void M3_airPlaceSurBlocJamaisChangeToujoursVu() { + assertTrue(clicsAir(new Moteur(new GardeConfig()), 1000, 10_000, false) > 0); + } + + @Test + void M3_changementAncienNeCouvrePas() { + Moteur m = new Moteur(new GardeConfig()); + double pts = 0; + for (int i = 0; i < 10; i++) { + long t = 10_000 + i * 500L; + m.changementBloc(joueur, 7, t - 2000); // changé il y a 2 s : plus un bloc fantôme + for (Verdict x : m.interactionBloc(joueur, t, 7, 0, EtatJoueur.normal(), OEIL, CUBE, 1, IMPACT, true, true, 4.5, 0)) { + if (x.controle() == Controle.INTERACTION_BLOC) pts += x.points(); + } + } + assertTrue(pts > 0); + } + + @Test + void M3_memoireCirculaire() { + Suivi.PositionsRecentes r = new Suivi.PositionsRecentes(); + for (int i = 0; i < 40; i++) r.noter(i, 1000); + assertFalse(r.contient(0, 1000, 0), "entrée la plus ancienne écrasée"); + assertTrue(r.contient(39, 1000, 0)); + assertFalse(r.contient(39, 999, 10), "instant futur refusé"); + } +}