diff --git a/src/main/java/com/gastinelgarde/Garde.java b/src/main/java/com/gastinelgarde/Garde.java index 464d1ad..c78e008 100644 --- a/src/main/java/com/gastinelgarde/Garde.java +++ b/src/main/java/com/gastinelgarde/Garde.java @@ -92,6 +92,8 @@ public final class Garde { // #92 : œil aux deux derniers paquets de mouvement (le client vise depuis une position entre les deux) double[] oeilDernier; double[] oeilAvant; + // 0.6 (scaffold) : rotation des deux derniers paquets de mouvement acceptés + float yawDernier = Float.NaN, pitchDernier, yawAvant = Float.NaN, pitchAvant; } /** #92 : historique des boîtes d'une entité suivie (joueurs, et entités frappées récemment). */ @@ -444,10 +446,115 @@ public final class Garde { // 0.5 (P3, revue) : joueur en cours d'expulsion : interaction annulée (comme les coups, C4). Avant, le doublon // main secondaire d'un clic qui venait d'expulser se lisait « autorisé ». if (MOTEUR.estExpulse(p.getUUID())) return true; + autrePaquet(p); // 0.6 (blink) List 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); + boolean annulerScaffold = poseScaffold(p, pos, face, impact, mainPrincipale); + return Cablage.sanctionDeMouvement(s) || annulerScaffold; + } + + /** + * 0.6 (P3.2) : clic droit avec un bloc en main qui posera un bloc de pont sous les pieds. La pose est jugée au paquet + * de mouvement suivant ; vrai si elle doit être annulée (scaffold en ENFORCE, période suspecte). Non testé en jeu. + */ + private static boolean poseScaffold(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face, + net.minecraft.world.phys.Vec3 impact, boolean mainPrincipale) { + if (CONFIG.mode(Controle.SCAFFOLD) == Mode.OFF || impact == null || face == null + || estExempteManuellement(p.getUUID())) return false; + net.minecraft.world.InteractionHand main = mainPrincipale ? net.minecraft.world.InteractionHand.MAIN_HAND + : net.minecraft.world.InteractionHand.OFF_HAND; + if (!(p.getItemInHand(main).getItem() instanceof net.minecraft.world.item.BlockItem)) return false; + if (!mainPrincipale && p.getMainHandItem().getItem() instanceof net.minecraft.world.item.BlockItem) return false; + BlockPos cible = p.level().getBlockState(pos).canBeReplaced() ? pos : pos.relative(face); + Marques m = marques(p.getUUID()); + if (m.oeilDernier == null || m.oeilAvant == null || Float.isNaN(m.yawAvant)) return false; + double dx = m.oeilDernier[0] - m.oeilAvant[0], dz = m.oeilDernier[2] - m.oeilAvant[2]; + double dy = m.oeilDernier[1] - m.oeilAvant[1]; + if (!com.gastinelgarde.core.Scaffold.estPont(cible.getX(), cible.getY(), cible.getZ(), p.getX(), p.getY(), p.getZ(), + dy, Math.sqrt(dx * dx + dz * dz))) return false; + int tick = p.server.getTickCount(); + boolean annuler = MOTEUR.scaffoldAnnuler(p.getUUID(), tick * 50L, tick); + net.minecraft.world.phys.Vec3 oeil = p.getEyePosition(); + float[] dir = com.gastinelgarde.core.Scaffold.rotation(impact.x - oeil.x, impact.y - oeil.y, impact.z - oeil.z); + MOTEUR.poseScaffold(p.getUUID(), etat(p, true), dir[0], dir[1], m.yawAvant, m.pitchAvant, p.getYRot(), p.getXRot()); + return annuler; + } + + /** 0.6 (P3.4) : un paquet autre que de mouvement vient d'être traité sur le thread serveur (blink). */ + public static void autrePaquet(ServerPlayer p) { + if (!surThreadServeur(p) || CONFIG.mode(Controle.BLINK) == Mode.OFF) return; + MOTEUR.autrePaquet(p.getUUID(), p.server.getTickCount()); + } + + /** 0.6 (P2.6) : le serveur ouvre (vrai) ou ferme un conteneur pour ce joueur (PlayerContainerEvent). */ + public static void noterConteneur(ServerPlayer p, boolean ouvert) { + if (!surThreadServeur(p)) return; + if (ouvert) MOTEUR.ouvrirConteneur(p.getUUID(), p.server.getTickCount()); + else MOTEUR.fermerConteneur(p.getUUID()); + } + + /** + * 0.6 (P2.6) : clic de conteneur (mixin, après ensureRunningOnSameThread). Vrai si le clic doit être ignoré + * (inventaire en ENFORCE au palier SETBACK, ou expulsion en cours) ; le menu est alors renvoyé au client. + */ + public static boolean noterClicConteneur(ServerPlayer p, int idConteneur, int numCase, + net.minecraft.world.inventory.ClickType type) { + if (!surThreadServeur(p)) return false; + if (MOTEUR.estExpulse(p.getUUID())) return true; + autrePaquet(p); + if (CONFIG.mode(Controle.INVENTAIRE) == Mode.OFF || estExempteManuellement(p.getUUID())) return false; + net.minecraft.world.inventory.AbstractContainerMenu menu = p.containerMenu; + boolean idValide = idConteneur == menu.containerId; + boolean menuConteneur = menu != p.inventoryMenu; + boolean caseConteneur = false; + int objet = 0; + if (idValide && numCase >= 0 && numCase < menu.slots.size()) { + net.minecraft.world.inventory.Slot c = menu.getSlot(numCase); + caseConteneur = !(c.container instanceof net.minecraft.world.entity.player.Inventory); + net.minecraft.world.item.ItemStack st = c.getItem(); + if (!st.isEmpty()) objet = net.minecraft.core.registries.BuiltInRegistries.ITEM.getId(st.getItem()) + 1; + } + com.gastinelgarde.core.Inventaire.Clic clic = switch (type) { + case QUICK_MOVE, SWAP -> com.gastinelgarde.core.Inventaire.Clic.PRISE; + case THROW -> menuConteneur ? com.gastinelgarde.core.Inventaire.Clic.AUTRE : com.gastinelgarde.core.Inventaire.Clic.PRISE; + default -> com.gastinelgarde.core.Inventaire.Clic.AUTRE; + }; + int tick = p.server.getTickCount(); + List v = MOTEUR.clicConteneur(p.getUUID(), tick * 50L, tick, etat(p, false), idValide, menuConteneur, + clic, caseConteneur, objet); + Sanction s = traiter(p, v); + if (s == Sanction.EXPULSION) { + appliquerSanctionMouvement(p, s, v); + return true; + } + if (Cablage.sanctionDeMouvement(s)) { + menu.sendAllDataToRemote(); // le client a prédit le clic : on lui renvoie l'état réel + return true; + } + return false; + } + + /** + * 0.6 (P3.5) : paquet de mouvement refusé par vanilla (mixin, juste avant le teleport() de refus). La boîte déclarée + * chevauche-t-elle un bloc solide, alors que celle de la dernière position acceptée est libre ? Non testé en jeu. + */ + public static void refusMouvement(ServerPlayer p, double x, double y, double z) { + if (!surThreadServeur(p) || CONFIG.mode(Controle.PHASE) == Mode.OFF || MOTEUR.estExpulse(p.getUUID()) + || estExempteManuellement(p.getUUID()) || p.isSleeping() || p.isPassenger()) return; + Marques m = marques(p.getUUID()); + if (m.mouvementTick == Integer.MIN_VALUE || !Double.isFinite(x + y + z)) return; + double dist = Math.sqrt(Math.pow(x - m.mouvementX, 2) + Math.pow(y - m.mouvementY, 2) + Math.pow(z - m.mouvementZ, 2)); + if (dist > 16) return; // lecture de blocs bornée (chunks peut-être non chargés) ; vanilla refuse déjà ce saut + net.minecraft.world.entity.EntityDimensions d = p.getDimensions(p.getPose()); + net.minecraft.world.phys.AABB avant = d.makeBoundingBox(m.mouvementX, m.mouvementY, m.mouvementZ).deflate(1.0E-3); + net.minecraft.world.phys.AABB declaree = d.makeBoundingBox(x, y, z).deflate(1.0E-3); + // Déjà coincé dans un bloc (sable tombé, piston) : pas une tentative de phase. + boolean dansBloc = p.level().noCollision(p, avant) && !p.level().noCollision(p, declaree); + int tick = p.server.getTickCount(); + List v = MOTEUR.refusPhase(p.getUUID(), tick * 50L, etat(p, true), dansBloc, dist); + Sanction s = traiter(p, v); // vanilla a déjà refusé la position : journal, VL et expulsion seulement + if (s == Sanction.EXPULSION) appliquerSanctionMouvement(p, s, v); } private static List verdictsInteraction(ServerPlayer p, BlockPos pos, net.minecraft.core.Direction face, @@ -508,6 +615,7 @@ public final class Garde { */ public static boolean noterCompletion(ServerPlayer p) { if (!surThreadServeur(p)) return false; + autrePaquet(p); // 0.6 (blink) if (CONFIG.mode(Controle.COMPLETION) == Mode.OFF) return false; if (MOTEUR.estExpulse(p.getUUID())) return true; List v = MOTEUR.completion(p.getUUID(), System.currentTimeMillis(), etat(p, false)); @@ -840,6 +948,12 @@ public final class Garde { List v = MOTEUR.paquetMouvement(p.getUUID(), System.currentTimeMillis(), etat); Sanction s = traiter(p, v); if (Cablage.sanctionDeMouvement(s)) appliquerSanctionMouvement(p, s, v); + if (CONFIG.mode(Controle.BLINK) != Mode.OFF) { // 0.6 (P3.4) + int tick = p.server.getTickCount(); + List vb = MOTEUR.mouvementBlink(p.getUUID(), tick * 50L, tick, etat, p.isAlive()); + Sanction sb = traiter(p, vb); + if (Cablage.sanctionDeMouvement(sb)) appliquerSanctionMouvement(p, sb, vb); + } } /** Fin du traitement d'un paquet accepté : mémorise la position valide et trace. */ @@ -887,6 +1001,23 @@ public final class Garde { // #92 : œil des deux derniers paquets, pour le prochain coup. m.oeilAvant = m.oeilDernier; m.oeilDernier = new double[] {oeil.x, oeil.y, oeil.z}; + // 0.6 : inventaire (rotation avec un conteneur ouvert) et scaffold (pose de pont jugée sur ce regard). + if (CONFIG.mode(Controle.INVENTAIRE) != Mode.OFF) { + if (p.containerMenu == p.inventoryMenu) MOTEUR.fermerConteneur(p.getUUID()); + List vi = MOTEUR.regardInventaire(p.getUUID(), tick * 50L, tick, etat(p, false), + p.getYRot(), p.getXRot()); + Sanction si = traiter(p, vi); + if (si == Sanction.EXPULSION) appliquerSanctionMouvement(p, si, vi); + } + if (CONFIG.mode(Controle.SCAFFOLD) != Mode.OFF) { + List vs = MOTEUR.regardScaffold(p.getUUID(), tick * 50L, tick, p.getYRot(), p.getXRot()); + Sanction ss = traiter(p, vs); // pose déjà faite : les suivantes sont annulées (scaffoldAnnuler) + if (ss == Sanction.EXPULSION) appliquerSanctionMouvement(p, ss, vs); + } + m.yawAvant = m.yawDernier; + m.pitchAvant = m.pitchDernier; + m.yawDernier = p.getYRot(); + m.pitchDernier = p.getXRot(); } // 0.4.0 : recul mesuré (anti-recul) et totem remis en main (auto-totem), sur les mêmes paquets. if (!estExempteManuellement(p.getUUID()) && (CONFIG.mode(Controle.VELOCITE) != Mode.OFF diff --git a/src/main/java/com/gastinelgarde/GardeEvents.java b/src/main/java/com/gastinelgarde/GardeEvents.java index 70814f6..0312d36 100644 --- a/src/main/java/com/gastinelgarde/GardeEvents.java +++ b/src/main/java/com/gastinelgarde/GardeEvents.java @@ -57,6 +57,7 @@ public final class GardeEvents { @SubscribeEvent public static void onAttaque(AttackEntityEvent event) { if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; + Garde.autrePaquet(p); // 0.6 (blink) : un coup est un paquet traité sur le thread serveur switch (Cablage.entreeAttaque(Garde.moteur().estExpulse(p.getUUID()), Garde.estExempteManuellement(p.getUUID()))) { case ANNULER -> { // C4 : expulsion en cours event.setCanceled(true); @@ -135,6 +136,7 @@ public final class GardeEvents { if (event.getLevel().isClientSide()) return; if (!(event.getEntity() instanceof ServerPlayer p) || p instanceof FakePlayer) return; var a = event.getAction(); + Garde.autrePaquet(p); // 0.6 (blink) // 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(), event.getFace()); @@ -239,6 +241,17 @@ public final class GardeEvents { } } + /** 0.6 (P2.6) : conteneur ouvert / fermé côté serveur (inventaire : réaction, rotation écran ouvert). */ + @SubscribeEvent + public static void onOuvertureConteneur(net.neoforged.neoforge.event.entity.player.PlayerContainerEvent.Open event) { + if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterConteneur(p, true); + } + + @SubscribeEvent + public static void onFermetureConteneur(net.neoforged.neoforge.event.entity.player.PlayerContainerEvent.Close event) { + if (event.getEntity() instanceof ServerPlayer p && !(p instanceof FakePlayer)) Garde.noterConteneur(p, false); + } + @SubscribeEvent public static void onConnexion(PlayerEvent.PlayerLoggedInEvent event) { if (event.getEntity() instanceof ServerPlayer p) { diff --git a/src/main/java/com/gastinelgarde/GardeSpec.java b/src/main/java/com/gastinelgarde/GardeSpec.java index f560f64..1e2e158 100644 --- a/src/main/java/com/gastinelgarde/GardeSpec.java +++ b/src/main/java/com/gastinelgarde/GardeSpec.java @@ -40,6 +40,8 @@ public final class GardeSpec { // 0.5 (P3) private static final ModConfigSpec.IntValue NUKER_MAX, NUKER_SERIE, CRISTAL_DELAI, CRISTAL_SERIE, TOWER_INTERVALLE, TOWER_SERIE, COMPLETION_PAR_S, COMPLETION_RAFALE; + /** 0.6 : réglages des sections [inventaire], [scaffold], [blink], [phase] ; clé = nom du champ de GardeConfig. */ + private static final java.util.Map> V06 = new java.util.LinkedHashMap<>(); private static final ModConfigSpec.DoubleValue ANGLE_MAX; private static final ModConfigSpec.IntValue CIBLES_MAX; @@ -347,6 +349,51 @@ public final class GardeSpec { .defineInRange("completionRafaleMax", 40, 5, 1000); b.pop(); + // 0.6 : une section par contrôle, avec ses propres seuils de VL (<= 0 : seuils globaux de [sanctions]). + b.comment("0.6 (P2.6) inventaire : ChestStealer, InventoryMove, InvCleaner / AutoArmor. OBSERVE par défaut.", + "Les mods d'inventaire côté client (Mouse Tweaks, Inventory Profiles) font des rafales de shift-clics : à observer avant ENFORCE.").push("inventaire"); + V06.put("inventaireReactionMinMs", b.comment("Réaction minimale (ms, ping retiré) entre l'ouverture d'un conteneur et la première prise.") + .defineInRange("inventaireReactionMinMs", 100, 0, 1000)); + V06.put("inventaireIntervalleMaxTicks", b.comment("Intervalle moyen (ticks) entre deux prises d'objets différents au-delà duquel la session n'est pas suspecte.") + .defineInRange("inventaireIntervalleMaxTicks", 1.5, 0.0, 20.0)); + V06.put("inventairePrisesMin", b.comment("Prises d'objets différents dans la session avant de juger.") + .defineInRange("inventairePrisesMin", 4, 2, 54)); + V06.put("inventairePingMaxMs", b.comment("Ping (ms) au plus retiré de la réaction (le ping est falsifiable).") + .defineInRange("inventairePingMaxMs", 300, 0, 2000)); + V06.put("inventaireGraceRotationTicks", b.comment("Grâce (ticks) après l'ouverture avant de compter les rotations (plus ping / 50).") + .defineInRange("inventaireGraceRotationTicks", 10, 0, 200)); + V06.put("inventaireRotationsMin", b.comment("Rotations avec un conteneur ouvert (une ouverture) avant que chacune compte.") + .defineInRange("inventaireRotationsMin", 3, 1, 100)); + V06.put("inventaireSeuilSetback", b.defineInRange("inventaireSeuilSetback", 10.0, 0.0, 1000.0)); + V06.put("inventaireSeuilExpulsion", b.defineInRange("inventaireSeuilExpulsion", 30.0, 0.0, 1000.0)); + b.pop(); + b.comment("0.6 (P3.2) scaffold horizontal : pont posé sous les pieds hors du regard ou avec des rotations aller-retour (snap). OBSERVE par défaut.").push("scaffold"); + V06.put("scaffoldAngleMaxDeg", b.comment("Écart (degrés) entre le regard et le point cliqué au-delà duquel la pose est hors regard.") + .defineInRange("scaffoldAngleMaxDeg", 50.0, 10.0, 180.0)); + V06.put("scaffoldSnapDeg", b.comment("Rotation (degrés) aller puis retour autour d'une pose au-delà de laquelle c'est un snap.") + .defineInRange("scaffoldSnapDeg", 70.0, 20.0, 180.0)); + V06.put("scaffoldSerieMin", b.comment("Poses anormales parmi les 10 dernières poses de pont (30 s) avant de compter.") + .defineInRange("scaffoldSerieMin", 4, 1, 10)); + V06.put("scaffoldSeuilSetback", b.defineInRange("scaffoldSeuilSetback", 10.0, 0.0, 1000.0)); + V06.put("scaffoldSeuilExpulsion", b.defineInRange("scaffoldSeuilExpulsion", 30.0, 0.0, 1000.0)); + b.pop(); + b.comment("0.6 (P3.4) blink : trou de paquets de mouvement pendant que d'autres paquets arrivent. OBSERVE par défaut.", + "Un blink qui retient tous les paquets ressemble à un vrai lag : il n'est pas détecté ici.").push("blink"); + V06.put("blinkTrouMinTicks", b.comment("Trou (ticks) sans mouvement à partir duquel il est mesuré (vanilla : un paquet au moins toutes les 20).") + .defineInRange("blinkTrouMinTicks", 30, 22, 600)); + V06.put("blinkAutresMin", b.comment("Autres paquets (ticks distincts) reçus pendant le trou avant de le juger.") + .defineInRange("blinkAutresMin", 2, 1, 100)); + V06.put("blinkSeuilSetback", b.defineInRange("blinkSeuilSetback", 10.0, 0.0, 1000.0)); + V06.put("blinkSeuilExpulsion", b.defineInRange("blinkSeuilExpulsion", 30.0, 0.0, 1000.0)); + b.pop(); + b.comment("0.6 (P3.5) phase : positions refusées par vanilla dont la boîte est dans un bloc solide (tentatives de NoClip / VClip).", + "Vanilla refuse déjà le passage ; ce contrôle compte les tentatives. OBSERVE par défaut.").push("phase"); + V06.put("phaseSerieMin", b.comment("Refus dans un bloc en 10 s avant que chacun compte.") + .defineInRange("phaseSerieMin", 5, 1, 32)); + V06.put("phaseSeuilSetback", b.defineInRange("phaseSeuilSetback", 10.0, 0.0, 1000.0)); + V06.put("phaseSeuilExpulsion", b.defineInRange("phaseSeuilExpulsion", 30.0, 0.0, 1000.0)); + b.pop(); + b.comment("0.5 (P2.10) x-ray statistique : alerte seulement, jamais de setback ni d'expulsion (même en ENFORCE).").push("xray"); XRAY_PCT = b.comment("Part (%) de minerais rares (diamant, débris antiques) parmi les blocs cassés en profondeur au-delà de laquelle on alerte.") .defineInRange("xrayAlerteDiamantsParCent", 5.0, 0.5, 100.0); @@ -556,6 +603,17 @@ public final class GardeSpec { c.towerSerie = TOWER_SERIE.get(); c.completionParSecondeMax = COMPLETION_PAR_S.get(); c.completionRafaleMax = COMPLETION_RAFALE.get(); + // 0.6 : champs du même nom dans GardeConfig (vérifié par Garde06Test). + for (java.util.Map.Entry> e : V06.entrySet()) { + try { + java.lang.reflect.Field f = GardeConfig.class.getField(e.getKey()); + Object val = e.getValue().get(); + if (f.getType() == int.class) f.setInt(c, ((Number) val).intValue()); + else f.setDouble(c, ((Number) val).doubleValue()); + } catch (ReflectiveOperationException ex) { + throw new IllegalStateException("reglage 0.6 sans champ : " + e.getKey(), ex); + } + } 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/Blink.java b/src/main/java/com/gastinelgarde/core/Blink.java new file mode 100644 index 0000000..0334982 --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/Blink.java @@ -0,0 +1,66 @@ +package com.gastinelgarde.core; + +/** + * 0.6 (P3.4) : Blink / FakeLag. Le client vanilla envoie un paquet de position au moins toutes les 20 ticks, même + * immobile ({@code positionReminder}, LocalPlayer). TCP garde l'ordre des paquets : pendant un vrai lag, tous + * les paquets attendent, puis arrivent ensemble dans l'ordre (mouvements et clics mêlés). Le Blink retient seulement + * les paquets de mouvement et laisse passer le reste (coups, clics, interactions) : le serveur reçoit alors d'autres + * paquets alors qu'aucun mouvement n'est arrivé depuis plus de 20 ticks. + * + * Signal : un trou d'au moins {@link GardeConfig#blinkTrouMinTicks} (30) ticks entre deux paquets de mouvement, pendant + * lequel d'autres paquets traités sur le thread serveur sont arrivés à au moins {@link GardeConfig#blinkAutresMin} (2) + * ticks distincts, chacun plus de 21 ticks après le dernier mouvement. Un gel du client (un seul tick de rattrapage : + * clic puis mouvement dans la même rafale) ne fait qu'un seul tick. Un Blink qui retient tous les paquets est + * indistinguable d'un vrai lag : seul le timer (solde de paquets) en voit une partie. OBSERVE par défaut. + */ +public final class Blink { + + /** Au-delà, le rappel de position vanilla aurait dû arriver (20 ticks, plus un de gigue). */ + public static final int RAPPEL_TICKS = 21; + + private long dernierMouvTick = Long.MIN_VALUE; + private long dernierAutreTick = Long.MIN_VALUE; + private int autres; + private long dernierTrou; + private int dernierAutres; + + /** Un autre paquet (coup, clic sur un bloc, clic de conteneur, complétion…) vient d'être traité. */ + public void autrePaquet(long tick) { + if (dernierMouvTick == Long.MIN_VALUE || tick == dernierAutreTick) return; + if (tick - dernierMouvTick > RAPPEL_TICKS) { + autres++; + dernierAutreTick = tick; + } + } + + /** Paquet de mouvement : renvoie les points du trou qui se termine. */ + public double mouvement(long tick, GardeConfig cfg) { + double pts = 0; + if (dernierMouvTick != Long.MIN_VALUE) { + dernierTrou = tick - dernierMouvTick; + dernierAutres = autres; + if (dernierTrou >= Math.max(RAPPEL_TICKS + 1, cfg.blinkTrouMinTicks) && autres >= Math.max(1, cfg.blinkAutresMin)) { + pts = 2.0; + } + } + dernierMouvTick = tick; + dernierAutreTick = Long.MIN_VALUE; + autres = 0; + return pts; + } + + /** Exemption (téléportation, véhicule, mort, gel du serveur…) : le prochain mouvement repart de zéro. */ + public void vider() { + dernierMouvTick = Long.MIN_VALUE; + dernierAutreTick = Long.MIN_VALUE; + autres = 0; + } + + public long dernierTrou() { + return dernierTrou; + } + + public int dernierAutres() { + return dernierAutres; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Controle.java b/src/main/java/com/gastinelgarde/core/Controle.java index 626cca3..1ffae6d 100644 --- a/src/main/java/com/gastinelgarde/core/Controle.java +++ b/src/main/java/com/gastinelgarde/core/Controle.java @@ -53,7 +53,15 @@ public enum Controle { /** 0.5 (P3.2) : pilier monté plus vite que le saut vanilla, blocs posés sous les pieds (Scaffold Tower). */ TOWER("tower"), /** 0.5 (P3.7) : demandes de complétion de commande au-delà d'un débit humain (spam de Tab, paquets forgés). */ - COMPLETION("completion"); + COMPLETION("completion"), + /** 0.6 (P2.6) : ChestStealer, InventoryMove, InvCleaner / AutoArmor. */ + INVENTAIRE("inventaire"), + /** 0.6 (P3.2) : pont posé sous les pieds hors du regard ou avec des rotations « snap » (Scaffold horizontal). */ + SCAFFOLD("scaffold"), + /** 0.6 (P3.4) : trou de paquets de mouvement pendant que d'autres paquets arrivent (Blink / FakeLag). */ + BLINK("blink"), + /** 0.6 (P3.5) : positions refusées par vanilla dans un bloc solide, en série (Phase / NoClip / VClip). */ + PHASE("phase"); private final String id; @@ -83,7 +91,8 @@ public enum Controle { // 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, INTERACTION_BLOC, AUTO_TOTEM_REGULIER, - JESUS, OMNISPRINT, XRAY, NUKER, AUTO_CRISTAL, TOWER, COMPLETION -> 2; // 0.5 (P2) : idem + JESUS, OMNISPRINT, XRAY, NUKER, AUTO_CRISTAL, TOWER, COMPLETION, + INVENTAIRE, SCAFFOLD, BLINK, PHASE -> 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 2f33233..f32ccb4 100644 --- a/src/main/java/com/gastinelgarde/core/GardeConfig.java +++ b/src/main/java/com/gastinelgarde/core/GardeConfig.java @@ -243,6 +243,40 @@ public final class GardeConfig { /** Complétion : rafale permise (capacité du seau). */ public int completionRafaleMax = 40; + // --- 0.6 : inventaire, scaffold, blink, phase. OBSERVE par défaut, seuils de VL propres (<= 0 = seuil global) --- + /** Inventaire : réaction minimale (ms, ping retiré) entre l'ouverture d'un conteneur et la première prise. */ + public int inventaireReactionMinMs = 100; + /** Inventaire : intervalle moyen (ticks) entre deux prises au-delà duquel la session n'est pas suspecte. */ + public double inventaireIntervalleMaxTicks = 1.5; + /** Inventaire : prises d'objets différents dans la session avant de juger. */ + public int inventairePrisesMin = 4; + /** Inventaire : ping (ms) au plus retiré de la réaction (le ping est falsifiable). */ + public int inventairePingMaxMs = 300; + /** Inventaire : grâce (ticks) après l'ouverture avant de compter les rotations, plus ping / 50. */ + public int inventaireGraceRotationTicks = 10; + /** Inventaire : rotations avec un conteneur ouvert (une ouverture) avant que chacune compte. */ + public int inventaireRotationsMin = 3; + public double inventaireSeuilSetback = 10; + public double inventaireSeuilExpulsion = 30; + /** Scaffold : écart (degrés) entre le regard et le point cliqué au-delà duquel la pose est hors regard. */ + public double scaffoldAngleMaxDeg = 50; + /** Scaffold : rotation (degrés) aller puis retour autour d'une pose, au-delà de laquelle c'est un « snap ». */ + public double scaffoldSnapDeg = 70; + /** Scaffold : poses anormales parmi les 10 dernières poses de pont (30 s) avant de compter. */ + public int scaffoldSerieMin = 4; + public double scaffoldSeuilSetback = 10; + public double scaffoldSeuilExpulsion = 30; + /** Blink : trou (ticks) sans paquet de mouvement au-delà duquel il est mesuré (vanilla : un paquet au moins toutes les 20). */ + public int blinkTrouMinTicks = 30; + /** Blink : autres paquets (ticks distincts) reçus pendant le trou avant de le juger. */ + public int blinkAutresMin = 2; + public double blinkSeuilSetback = 10; + public double blinkSeuilExpulsion = 30; + /** Phase : positions refusées dans un bloc solide en 10 s avant que chacune compte. */ + public int phaseSerieMin = 5; + public double phaseSeuilSetback = 10; + public double phaseSeuilExpulsion = 30; + // --- 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 »). */ public boolean diagnosticActionsBloc = true; diff --git a/src/main/java/com/gastinelgarde/core/Inventaire.java b/src/main/java/com/gastinelgarde/core/Inventaire.java new file mode 100644 index 0000000..9b8571d --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/Inventaire.java @@ -0,0 +1,179 @@ +package com.gastinelgarde.core; + +/** + * 0.6 (P2.6) : inventaire (ChestStealer, InventoryMove, InvCleaner / AutoArmor). Trois signaux, tous en ticks serveur. + * + *
    + *
  1. vol-de-coffre : dans une même ouverture de conteneur (coffre, tonneau…), des prises (shift-clic ou touche + * de hotbar sur une case du conteneur) d'objets différents commencent moins de {@link GardeConfig#inventaireReactionMinMs} + * après l'ouverture (ping retiré, plafonné) et s'enchaînent à moins de {@link GardeConfig#inventaireIntervalleMaxTicks} + * en moyenne sur au moins {@link GardeConfig#inventairePrisesMin} prises. Le double-clic shift vanilla (même objet, + * même tick) n'est pas compté. Un humain a besoin d'au moins 150 ms pour voir l'écran s'ouvrir et viser la première + * case ; un ChestStealer prend dès la réception. Une fois la session jugée suspecte, chaque prise rapide + * suivante compte (annulable en ENFORCE).
  2. + *
  3. regard-conteneur (contre-contournement « ChestStealer silencieux » / InventoryMove) : le client vanilla ne + * tourne pas la tête quand un écran est ouvert (souris libérée). Une rotation reçue alors que le serveur voit un + * conteneur ouvert, au-delà d'une grâce après l'ouverture, est suspecte. Le stealer « silencieux » ferme l'écran côté + * client seulement : le serveur garde le conteneur ouvert et voit le joueur tourner.
  4. + *
  5. clic-en-rotation (InvCleaner, AutoArmor) : un clic sur l'inventaire du joueur (pas de paquet d'ouverture + * en vanilla) alors que la tête tournait au paquet précédent et au tick d'avant : impossible avec l'écran ouvert.
  6. + *
+ * Les clics sur un conteneur déjà fermé (identifiant différent, ignorés par vanilla) sont seulement comptés pour le + * journal. Les mods d'inventaire côté client (Mouse Tweaks, Inventory Profiles, Item Scroller) font des rafales de + * shift-clics : c'est pourquoi la réaction après l'ouverture est exigée, et pourquoi le contrôle reste en OBSERVE tant + * qu'il n'a pas été comparé à de vraies sessions. Le mod client InvMove (marcher écran ouvert) ne tourne pas la tête. + */ +public final class Inventaire { + + /** Type de clic (sous-ensemble de {@code ClickType} utile ici). */ + public enum Clic { PRISE, AUTRE } + + // Session d'ouverture d'un conteneur + private boolean ouvert; + private long ouvertTick; + private long premierePriseTick = Long.MIN_VALUE; + private long dernierePriseTick = Long.MIN_VALUE; + private int prises; + private int dernierObjet; + private boolean sessionSuspecte; + private int reactionMs = -1; + + // Rotation + private float yaw = Float.NaN, pitch = Float.NaN; + private long rotationTick = Long.MIN_VALUE; + private long rotationAvantTick = Long.MIN_VALUE; + private int rotationsConteneur; + + private final SerieFenetre clicsFermes = new SerieFenetre(10, 10_000); + private int dernierCompteFermes; + private String dernierDetail = ""; + + /** Le serveur vient d'ouvrir un conteneur pour ce joueur (PlayerContainerEvent.Open). */ + public void ouvrir(long tick) { + ouvert = true; + ouvertTick = tick; + premierePriseTick = Long.MIN_VALUE; + dernierePriseTick = Long.MIN_VALUE; + prises = 0; + dernierObjet = 0; + sessionSuspecte = false; + reactionMs = -1; + rotationsConteneur = 0; + } + + public void fermer() { + ouvert = false; + sessionSuspecte = false; + rotationsConteneur = 0; + } + + public boolean ouvert() { + return ouvert; + } + + /** + * Clic sur un conteneur ouvert. + * + * @param caseConteneur la case cliquée appartient au conteneur (pas à l'inventaire du joueur) + * @param objet empreinte de l'objet de la case (type d'objet), 0 si vide + * @param pingMs ping mesuré (falsifiable : plafonné par {@link GardeConfig#inventairePingMaxMs}) + * @param facteur tolérance (lag) : divise la réaction exigée et l'intervalle maximal + * @return points + */ + public double clicConteneur(long tick, Clic type, boolean caseConteneur, int objet, int pingMs, double facteur, + GardeConfig cfg) { + if (!ouvert || type != Clic.PRISE || !caseConteneur || objet == 0) return 0; + // Double-clic shift vanilla : même objet dans le même tick (toutes les cases de cet objet d'un coup). + if (tick == dernierePriseTick && objet == dernierObjet) return 0; + dernierObjet = objet; + if (prises == 0) { + premierePriseTick = tick; + int ping = Math.max(0, Math.min(pingMs, cfg.inventairePingMaxMs)); + reactionMs = (int) Math.max(0, (tick - ouvertTick) * 50 - ping); + } + long ecart = dernierePriseTick == Long.MIN_VALUE ? Long.MAX_VALUE : tick - dernierePriseTick; + dernierePriseTick = tick; + prises++; + // Lag : paquets regroupés (intervalles comprimés) et ticks plus longs que 50 ms : les deux limites se resserrent. + double intervalleMax = cfg.inventaireIntervalleMaxTicks / Math.max(1, facteur); + double reactionMin = cfg.inventaireReactionMinMs / Math.max(1, facteur); + double moyenne = prises <= 1 ? 0 : (double) (tick - premierePriseTick) / (prises - 1); + dernierDetail = String.format(java.util.Locale.ROOT, + "vol-de-coffre : %d prises, reaction %d ms (min %.0f), intervalle moyen %.2f ticks (max %.1f)", + prises, reactionMs, reactionMin, moyenne, intervalleMax); + if (!sessionSuspecte) { + if (prises >= Math.max(2, cfg.inventairePrisesMin) && reactionMs < reactionMin && moyenne <= intervalleMax) { + sessionSuspecte = true; + return 1.0; + } + return 0; + } + // Session déjà suspecte : chaque prise rapide suivante compte. + return ecart <= Math.ceil(intervalleMax) ? 1.0 : 0; + } + + /** + * Clic sur l'inventaire du joueur (aucun conteneur ouvert côté serveur) : InvCleaner / AutoArmor si la tête tourne. + */ + public double clicInventaire(long tick, Clic type) { + if (ouvert || type != Clic.PRISE) return 0; + boolean tourne = rotationTick != Long.MIN_VALUE && tick - rotationTick <= 1 + && rotationAvantTick != Long.MIN_VALUE && rotationTick - rotationAvantTick <= 2; + dernierDetail = "clic-en-rotation : clic sur l'inventaire pendant que la tete tourne (dernieres rotations a " + + (rotationTick == Long.MIN_VALUE ? "?" : String.valueOf(tick - rotationTick)) + " tick(s))"; + return tourne ? 0.5 : 0; + } + + /** Clic sur un conteneur fermé (identifiant périmé) : journal seulement, quelques-uns arrivent avec le lag. */ + public boolean clicFerme(long nowMs) { + dernierCompteFermes = clicsFermes.ajouter(nowMs, true); + return dernierCompteFermes >= 10; + } + + public int clicsFermes() { + return dernierCompteFermes; + } + + /** + * Rotation reçue (paquet de mouvement accepté). + * + * @param graceTicks grâce après l'ouverture (le client ne voit l'écran qu'après un aller-retour) + * @return points (regard-conteneur) + */ + public double regard(long tick, float nYaw, float nPitch, int graceTicks, GardeConfig cfg) { + boolean change = !Float.isNaN(yaw) && (angle(yaw, nYaw) > 0.5 || Math.abs(nPitch - pitch) > 0.5); + if (Float.isNaN(yaw) || change) { + if (change) { + rotationAvantTick = rotationTick; + rotationTick = tick; + } + yaw = nYaw; + pitch = nPitch; + } + if (!change || !ouvert || tick - ouvertTick <= graceTicks) return 0; + rotationsConteneur++; + dernierDetail = String.format(java.util.Locale.ROOT, + "regard-conteneur : %d rotation(s) avec un conteneur ouvert depuis %d ticks (grace %d)", + rotationsConteneur, tick - ouvertTick, graceTicks); + return rotationsConteneur >= Math.max(1, cfg.inventaireRotationsMin) ? 0.5 : 0; + } + + /** Une grâce (téléportation, véhicule…) a remis le regard à zéro : la rotation suivante n'est pas comptée. */ + public void oublierRegard() { + yaw = Float.NaN; + rotationsConteneur = 0; + } + + public String detail() { + return dernierDetail; + } + + public boolean sessionSuspecte() { + return sessionSuspecte; + } + + static double angle(float a, float b) { + double d = Math.abs(((b - a) % 360 + 540) % 360 - 180); + return d; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Moteur.java b/src/main/java/com/gastinelgarde/core/Moteur.java index 8cb3900..1e41618 100644 --- a/src/main/java/com/gastinelgarde/core/Moteur.java +++ b/src/main/java/com/gastinelgarde/core/Moteur.java @@ -608,6 +608,147 @@ public final class Moteur { return v; } + // --- 0.6 : inventaire, scaffold horizontal, blink, phase (OBSERVE par défaut) --------------------------- + + private boolean actif(UUID joueur, Controle c) { + return !expulses.contains(joueur) && cfg.mode(c) != Mode.OFF; + } + + /** 0.6 (P2.6) : le serveur ouvre un conteneur (coffre, tonneau…) pour ce joueur. */ + public void ouvrirConteneur(UUID joueur, long tick) { + if (actif(joueur, Controle.INVENTAIRE)) suivi(joueur).inventaire.ouvrir(tick); + } + + /** 0.6 (P2.6) : conteneur fermé (par le joueur, le serveur ou la distance). */ + public void fermerConteneur(UUID joueur) { + Suivi s = suivis.get(joueur); + if (s != null) s.inventaire.fermer(); + } + + /** + * 0.6 (P2.6) : clic de conteneur reçu (après ensureRunningOnSameThread). + * + * @param idValide l'identifiant du paquet est celui du menu ouvert côté serveur (sinon vanilla l'ignore) + * @param menuConteneur un conteneur est ouvert côté serveur (pas l'inventaire du joueur) + * @param caseConteneur la case cliquée appartient au conteneur + * @param objet empreinte du type d'objet de la case (0 si vide) + */ + public List clicConteneur(UUID joueur, long nowMs, long tick, EtatJoueur etat, boolean idValide, + boolean menuConteneur, Inventaire.Clic type, boolean caseConteneur, int objet) { + if (!actif(joueur, Controle.INVENTAIRE)) return List.of(); + Suivi s = suivi(joueur); + Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE); + if (ex.exempt()) return List.of(); + double f = etat.tps() < cfg.tpsLag ? Math.max(ex.facteur(), cfg.facteurLag) : ex.facteur(); + List v = new ArrayList<>(1); + if (!idValide) { + if (s.inventaire.clicFerme(nowMs)) { + // journal seulement (points minimes) : le lag après une fermeture en produit quelques-uns + ajouter(v, s, Controle.INVENTAIRE, 0.1, nowMs, ex, "clic-ferme : " + s.inventaire.clicsFermes() + + " clics sur un conteneur deja ferme en 10 s (ignores par vanilla)"); + } + return v; + } + double pts; + if (menuConteneur) { + pts = s.inventaire.clicConteneur(tick, type, caseConteneur, objet, etat.pingMs(), f, cfg); + } else { + Exemptions.Resultat exM = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT); + pts = exM.exempt() ? 0 : s.inventaire.clicInventaire(tick, type); + } + ajouter(v, s, Controle.INVENTAIRE, pts, nowMs, ex, s.inventaire.detail()); + return v; + } + + /** 0.6 (P2.6) : rotation acceptée ; compte celles reçues avec un conteneur ouvert (InventoryMove, stealer silencieux). */ + public List regardInventaire(UUID joueur, long nowMs, long tick, EtatJoueur etat, float yaw, float pitch) { + if (!actif(joueur, Controle.INVENTAIRE)) return List.of(); + Suivi s = suivi(joueur); + Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT); + Exemptions.Resultat exW = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE); + if (ex.exempt() || exW.exempt() || etat.tps() < cfg.tpsLag) { + s.inventaire.oublierRegard(); + return List.of(); + } + // Ping élevé : le client voit l'écran s'ouvrir un aller-retour plus tard (plafonné : le ping est falsifiable). + int grace = cfg.inventaireGraceRotationTicks + Math.min(Math.max(0, etat.pingMs()), cfg.inventairePingMaxMs * 2) / 50; + double pts = s.inventaire.regard(tick, yaw, pitch, grace, cfg); + List v = new ArrayList<>(1); + ajouter(v, s, Controle.INVENTAIRE, pts, nowMs, ex, s.inventaire.detail()); + return v; + } + + /** 0.6 (P3.2) : pose d'un bloc de pont (voir {@link Scaffold#estPont}) ; jugée au paquet de mouvement suivant. */ + public void poseScaffold(UUID joueur, EtatJoueur etat, float dirYaw, float dirPitch, float yawAvant, + float pitchAvant, float yawPose, float pitchPose) { + if (!actif(joueur, Controle.SCAFFOLD)) return; + Suivi s = suivi(joueur); + if (Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE).exempt() + || Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT).exempt() || etat.tps() < cfg.tpsLag) { + s.scaffold.vider(); + return; + } + s.scaffold.pose(dirYaw, dirPitch, yawAvant, pitchAvant, yawPose, pitchPose); + } + + /** 0.6 (P3.2) : vrai si une pose de pont doit être annulée (ENFORCE, période suspecte, VL au palier SETBACK). */ + public boolean scaffoldAnnuler(UUID joueur, long nowMs, long tick) { + if (cfg.mode(Controle.SCAFFOLD) != Mode.ENFORCE) return false; + Suivi s = suivis.get(joueur); + if (s == null || !s.scaffold.suspect(tick)) return false; + return Paliers.palier(s.vl.valeur(Controle.SCAFFOLD, nowMs), cfg, Controle.SCAFFOLD).ordinal() >= Sanction.SETBACK.ordinal(); + } + + /** 0.6 (P3.2) : paquet de mouvement accepté : juge la dernière pose de pont, s'il y en a une. */ + public List regardScaffold(UUID joueur, long nowMs, long tick, float yaw, float pitch) { + if (!actif(joueur, Controle.SCAFFOLD)) return List.of(); + Suivi s = suivis.get(joueur); + if (s == null) return List.of(); + double pts = s.scaffold.regard(tick, nowMs, yaw, pitch, cfg); + List v = new ArrayList<>(1); + ajouter(v, s, Controle.SCAFFOLD, pts, nowMs, new Exemptions.Resultat(false, 1.0, List.of()), s.scaffold.detail()); + return v; + } + + /** 0.6 (P3.4) : autre paquet traité sur le thread serveur (coup, clic sur un bloc, conteneur, complétion). */ + public void autrePaquet(UUID joueur, long tick) { + if (!actif(joueur, Controle.BLINK)) return; + suivi(joueur).blink.autrePaquet(tick); + } + + /** 0.6 (P3.4) : paquet de mouvement reçu (avant traitement). Exemptions TIMER, véhicule, mort, gel, TPS bas. */ + public List mouvementBlink(UUID joueur, long nowMs, long tick, EtatJoueur etat, boolean vivant) { + if (!actif(joueur, Controle.BLINK)) return List.of(); + Suivi s = suivi(joueur); + Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.TIMER); + if (ex.exempt() || !vivant || etat.enVehicule() || etat.ticksDepuisGel() <= cfg.graceGelTicks + || etat.tps() < cfg.tpsLag) { + s.blink.vider(); + return List.of(); + } + double pts = s.blink.mouvement(tick, cfg); + List v = new ArrayList<>(1); + ajouter(v, s, Controle.BLINK, pts, nowMs, ex, String.format(Locale.ROOT, + "trou de %d ticks sans mouvement, %d autre(s) paquet(s) recus pendant le trou (min %d, trou min %d)", + s.blink.dernierTrou(), s.blink.dernierAutres(), cfg.blinkAutresMin, cfg.blinkTrouMinTicks)); + return v; + } + + /** 0.6 (P3.5) : paquet de mouvement refusé par vanilla ; {@code dansBloc} si la boîte déclarée chevauche un bloc. */ + public List refusPhase(UUID joueur, long nowMs, EtatJoueur etat, boolean dansBloc, double distance) { + if (!actif(joueur, Controle.PHASE)) return List.of(); + Suivi s = suivi(joueur); + Exemptions.Resultat ex = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MOUVEMENT); + Exemptions.Resultat exW = Exemptions.evaluer(etat, cfg, Exemptions.Famille.MONDE); + if (ex.exempt() || exW.exempt() || etat.tps() < cfg.tpsLag) return List.of(); + double pts = s.phase.refus(nowMs, dansBloc, cfg); + List v = new ArrayList<>(1); + ajouter(v, s, Controle.PHASE, pts, nowMs, ex, String.format(Locale.ROOT, + "position refusee par vanilla dans un bloc solide (%.2f bloc(s) de la position acceptee), %d en 10 s (min %d)", + distance, s.phase.compte(), cfg.phaseSerieMin)); + return v; + } + /** * 0.5 (P3.7) : demande de complétion de commande reçue (horloge réelle : plusieurs paquets par tick). Aucune * exemption de jeu (rien ne dépend du mouvement). Voir {@link #completionAIgnorer}. diff --git a/src/main/java/com/gastinelgarde/core/Paliers.java b/src/main/java/com/gastinelgarde/core/Paliers.java index dea2264..a242da3 100644 --- a/src/main/java/com/gastinelgarde/core/Paliers.java +++ b/src/main/java/com/gastinelgarde/core/Paliers.java @@ -20,6 +20,22 @@ public final class Paliers { } else if (c == Controle.VELOCITE) { if (cfg.velociteSeuilSetback > 0) setback = cfg.velociteSeuilSetback; if (cfg.velociteSeuilExpulsion > 0) expulsion = cfg.velociteSeuilExpulsion; + } else if (c == Controle.INVENTAIRE || c == Controle.SCAFFOLD || c == Controle.BLINK || c == Controle.PHASE) { + // 0.6 : seuils propres (sections [inventaire], [scaffold], [blink], [phase]) ; <= 0 = seuil global. + double sb = switch (c) { + case INVENTAIRE -> cfg.inventaireSeuilSetback; + case SCAFFOLD -> cfg.scaffoldSeuilSetback; + case BLINK -> cfg.blinkSeuilSetback; + default -> cfg.phaseSeuilSetback; + }; + double ex = switch (c) { + case INVENTAIRE -> cfg.inventaireSeuilExpulsion; + case SCAFFOLD -> cfg.scaffoldSeuilExpulsion; + case BLINK -> cfg.blinkSeuilExpulsion; + default -> cfg.phaseSeuilExpulsion; + }; + if (sb > 0) setback = sb; + if (ex > 0) expulsion = ex; } setback = Math.min(setback, expulsion); double alerte = Math.min(cfg.seuilAlerte, setback); diff --git a/src/main/java/com/gastinelgarde/core/Phase.java b/src/main/java/com/gastinelgarde/core/Phase.java new file mode 100644 index 0000000..80afcfe --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/Phase.java @@ -0,0 +1,36 @@ +package com.gastinelgarde.core; + +/** + * 0.6 (P3.5) : Phase / NoClip / VClip. Vanilla (handleMovePlayer, sources NeoForge 21.1.234) refuse déjà d'entrer dans + * un bloc : le déplacement est rejoué avec collisions, et la position est refusée (« moved wrongly », ou + * {@code isPlayerCollidingWithAnythingNew}) avant d'être acceptée. Ce contrôle ne sanctionne donc pas un passage qui + * aurait réussi : il compte les tentatives, c'est-à-dire les positions refusées par vanilla dont la boîte + * déclarée chevauche un bloc solide (ou une entité solide). Un vrai joueur en provoque quelques-unes (porte qui se + * ferme, piston, bloc posé par un autre joueur pendant un lag) ; un client de phase en envoie en continu. + * + * Il faut {@link GardeConfig#phaseSerieMin} (5) refus dans un bloc en 10 s ; ensuite chaque refus compte. OBSERVE par + * défaut : le seuil n'a jamais été comparé à de vrais joueurs (Create, Sable et les ascenseurs peuvent en provoquer). + */ +public final class Phase { + + public static final long FENETRE_MS = 10_000; + + private final SerieFenetre serie = new SerieFenetre(32, FENETRE_MS); + private int compte; + + /** Paquet de mouvement refusé par vanilla ; {@code dansBloc} : la boîte déclarée chevauche un bloc solide. */ + public double refus(long nowMs, boolean dansBloc, GardeConfig cfg) { + if (!dansBloc) return 0; + compte = serie.ajouter(nowMs, true); + return compte >= Math.max(1, cfg.phaseSerieMin) ? 1.0 : 0; + } + + public int compte() { + return compte; + } + + public void vider() { + serie.vider(); + compte = 0; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Scaffold.java b/src/main/java/com/gastinelgarde/core/Scaffold.java new file mode 100644 index 0000000..176b6ee --- /dev/null +++ b/src/main/java/com/gastinelgarde/core/Scaffold.java @@ -0,0 +1,131 @@ +package com.gastinelgarde.core; + +import java.util.Locale; + +/** + * 0.6 (P3.2, partie « Scaffold horizontal ») : pont posé sous les pieds pendant la marche. Le client vanilla ne pose un + * bloc que là où vise le réticule : le point cliqué est sur le rayon du regard, au moment du clic. Le clic part entre + * la rotation du dernier paquet de mouvement et celle du suivant (la souris bouge à chaque image). Deux anomalies : + *
    + *
  • hors-regard : le point cliqué est à plus de {@link GardeConfig#scaffoldAngleMaxDeg} (50°) de toutes les + * rotations entre ces deux paquets (Scaffold sans rotation, pose « derrière soi ») ;
  • + *
  • snap (Scaffold à rotation silencieuse) : la rotation fait un aller de plus de + * {@link GardeConfig#scaffoldSnapDeg} (70°) juste avant la pose, puis un retour d'autant juste après, vers le regard + * d'avant. Un pont humain (ninja, god-bridge, pont en reculant) garde le regard à peu près fixe.
  • + *
+ * Il faut {@link GardeConfig#scaffoldSerieMin} (4) poses anormales parmi les 10 dernières poses de pont en 30 s ; ensuite + * chaque pose anormale compte et, pendant 2 s, les poses de pont suivantes sont annulables en ENFORCE (l'anomalie + * n'est connue qu'au paquet de mouvement d'après, la pose a déjà eu lieu). Les clics « derrière soi » de vrais + * joueurs qui retournent la tête très vite (180° en une image) sont possibles : OBSERVE par défaut. + */ +public final class Scaffold { + + public static final int SERIE = 10; + public static final long FENETRE_MS = 30_000; + public static final int ANNULATION_TICKS = 40; + + private final SerieFenetre serie = new SerieFenetre(SERIE, FENETRE_MS); + private boolean attente; + private float dirYaw, dirPitch, yawAvant, pitchAvant, yawPose, pitchPose; + private long suspectJusquaTick = Long.MIN_VALUE; + private int compte; + private String detail = ""; + + /** + * Le bloc posé fait-il partie d'un pont sous les pieds ? Bloc juste sous le niveau des pieds, à côté de la colonne du + * joueur (pas dedans : c'est le tower), joueur qui ne monte ni ne descend et qui avance. + */ + public static boolean estPont(int bx, int by, int bz, double px, double py, double pz, double dy, double vitesseH) { + boolean sousPieds = py >= by + 1 - 0.01 && py < by + 1.6; + boolean colonne = (int) Math.floor(px) == bx && (int) Math.floor(pz) == bz; + double hx = bx + 0.5 - px, hz = bz + 0.5 - pz; + boolean proche = hx * hx + hz * hz <= 1.8 * 1.8; + return sousPieds && !colonne && proche && Math.abs(dy) < 0.1 && vitesseH >= 0.03; + } + + /** + * Pose de pont : retenue jusqu'au paquet de mouvement suivant. + * + * @param dirYaw, dirPitch direction œil → point cliqué + * @param yawAvant, pitchAvant rotation du paquet d'avant le dernier + * @param yawPose, pitchPose rotation du dernier paquet (au moment de la pose) + */ + public void pose(float dirYaw, float dirPitch, float yawAvant, float pitchAvant, float yawPose, float pitchPose) { + this.attente = true; + this.dirYaw = dirYaw; + this.dirPitch = dirPitch; + this.yawAvant = yawAvant; + this.pitchAvant = pitchAvant; + this.yawPose = yawPose; + this.pitchPose = pitchPose; + } + + /** Paquet de mouvement accepté après une pose de pont : juge la pose. */ + public double regard(long tick, long nowMs, float yaw, float pitch, GardeConfig cfg) { + if (!attente) return 0; + attente = false; + double horsRegard = ecartArc(yawPose, pitchPose, yaw, pitch, dirYaw, dirPitch); + double aller = angle(yawAvant, pitchAvant, yawPose, pitchPose); + double retour = angle(yawPose, pitchPose, yaw, pitch); + double bilan = angle(yawAvant, pitchAvant, yaw, pitch); + boolean hors = horsRegard > cfg.scaffoldAngleMaxDeg; + boolean snap = aller >= cfg.scaffoldSnapDeg && retour >= cfg.scaffoldSnapDeg && bilan <= cfg.scaffoldSnapDeg / 2; + boolean anomalie = hors || snap; + compte = serie.ajouter(nowMs, anomalie); + detail = String.format(Locale.ROOT, + "pont : %s ecart au regard %.0f deg (max %.0f), aller %.0f / retour %.0f deg (snap %.0f), %d/%d anomalies", + hors ? "hors-regard," : snap ? "snap," : "", horsRegard, cfg.scaffoldAngleMaxDeg, aller, retour, + cfg.scaffoldSnapDeg, compte, SERIE); + if (anomalie && compte >= Math.max(1, cfg.scaffoldSerieMin)) { + suspectJusquaTick = tick + ANNULATION_TICKS; + return 1.0; + } + return 0; + } + + /** Pendant la période suspecte, une pose de pont est annulable en ENFORCE. */ + public boolean suspect(long tick) { + return tick <= suspectJusquaTick; + } + + public String detail() { + return detail; + } + + public void vider() { + attente = false; + serie.vider(); + suspectJusquaTick = Long.MIN_VALUE; + } + + /** Plus petit écart (degrés) entre la direction et les rotations sur l'arc le plus court de r0 à r1. */ + static double ecartArc(float y0, float p0, float y1, float p1, float dy, float dp) { + double dyaw = ((y1 - y0) % 360 + 540) % 360 - 180; + double min = Double.MAX_VALUE; + for (int i = 0; i <= 8; i++) { + double t = i / 8.0; + min = Math.min(min, angle((float) (y0 + dyaw * t), (float) (p0 + (p1 - p0) * t), dy, dp)); + } + return min; + } + + /** Angle (degrés) entre deux regards (yaw, pitch Minecraft). */ + static double angle(float y0, float p0, float y1, float p1) { + double[] a = vecteur(y0, p0), b = vecteur(y1, p1); + double c = a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; + return Math.toDegrees(Math.acos(Math.max(-1, Math.min(1, c)))); + } + + static double[] vecteur(float yaw, float pitch) { + double y = Math.toRadians(yaw), p = Math.toRadians(pitch); + return new double[] {-Math.sin(y) * Math.cos(p), -Math.sin(p), Math.cos(y) * Math.cos(p)}; + } + + /** Rotation Minecraft (yaw, pitch) d'une direction. */ + public static float[] rotation(double dx, double dy, double dz) { + double h = Math.sqrt(dx * dx + dz * dz); + float yaw = (float) Math.toDegrees(Math.atan2(-dx, dz)); + float pitch = (float) Math.toDegrees(Math.atan2(-dy, h)); + return new float[] {yaw, pitch}; + } +} diff --git a/src/main/java/com/gastinelgarde/core/Suivi.java b/src/main/java/com/gastinelgarde/core/Suivi.java index e6baaa3..96f4341 100644 --- a/src/main/java/com/gastinelgarde/core/Suivi.java +++ b/src/main/java/com/gastinelgarde/core/Suivi.java @@ -87,6 +87,11 @@ public final class Suivi { public final AutoCristal autoCristal = new AutoCristal(); /** 0.5 (P3.2) : tower. */ public final Tower tower = new Tower(); + /** 0.6 : inventaire, scaffold horizontal, blink, phase (oubliés à la déconnexion avec le Suivi). */ + public final Inventaire inventaire = new Inventaire(); + public final Scaffold scaffold = new Scaffold(); + public final Blink blink = new Blink(); + public final Phase phase = new Phase(); /** 0.5 (P3.7) : complétion de commande. */ public final Completion completion = new Completion(); public boolean completionExces; diff --git a/src/main/java/com/gastinelgarde/mixin/ContainerClickMixin.java b/src/main/java/com/gastinelgarde/mixin/ContainerClickMixin.java new file mode 100644 index 0000000..1107f0f --- /dev/null +++ b/src/main/java/com/gastinelgarde/mixin/ContainerClickMixin.java @@ -0,0 +1,35 @@ +package com.gastinelgarde.mixin; + +import com.gastinelgarde.Garde; +import net.minecraft.network.protocol.game.ServerboundContainerClickPacket; +import net.minecraft.server.level.ServerPlayer; +import net.minecraft.server.network.ServerGamePacketListenerImpl; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +/** + * 0.6 (P2.6) : clics de conteneur (ChestStealer, InvCleaner, AutoArmor). Hors ENFORCE, rien ne change ; en ENFORCE au + * palier SETBACK, le clic est ignoré et le menu renvoyé au client. + * + * Règle (F01) : injecté juste APRÈS ensureRunningOnSameThread (MixinsThreadTest), donc sur le thread serveur. + */ +@Mixin(ServerGamePacketListenerImpl.class) +public abstract class ContainerClickMixin { + + @Shadow public ServerPlayer player; + + @Inject(method = "handleContainerClick", + at = @At(value = "INVOKE", + target = "Lnet/minecraft/network/protocol/PacketUtils;ensureRunningOnSameThread(Lnet/minecraft/network/protocol/Packet;Lnet/minecraft/network/PacketListener;Lnet/minecraft/server/level/ServerLevel;)V", + shift = At.Shift.AFTER), + cancellable = true) + private void gastinelgarde$clicConteneur(ServerboundContainerClickPacket packet, CallbackInfo ci) { + if (player != null && Garde.noterClicConteneur(player, packet.getContainerId(), packet.getSlotNum(), + packet.getClickType())) { + ci.cancel(); + } + } +} diff --git a/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java b/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java index 883ff1d..7c02d2b 100644 --- a/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java +++ b/src/main/java/com/gastinelgarde/mixin/MovePacketMixin.java @@ -77,7 +77,10 @@ public abstract class MovePacketMixin { target = "Lnet/minecraft/server/network/ServerGamePacketListenerImpl;teleport(DDDFF)V")) private void gastinelgarde$refusVanilla(net.minecraft.network.protocol.game.ServerboundMovePlayerPacket packet, CallbackInfo ci) { - if (player != null) Garde.annoncerTeleport(player, GraceTeleport.Origine.REFUS_VANILLA); + if (player == null) return; + // 0.6 (P3.5) : position déclarée dans un bloc solide ? (avant l'annonce, qui ne change pas la grâce de toute façon) + Garde.refusMouvement(player, packet.getX(player.getX()), packet.getY(player.getY()), packet.getZ(player.getZ())); + Garde.annoncerTeleport(player, GraceTeleport.Origine.REFUS_VANILLA); } // Renvoi d'une téléportation non confirmée au bout d'une seconde : garde l'origine de la précédente. diff --git a/src/main/resources/gastinelgarde.mixins.json b/src/main/resources/gastinelgarde.mixins.json index d6a8de7..d1658a3 100644 --- a/src/main/resources/gastinelgarde.mixins.json +++ b/src/main/resources/gastinelgarde.mixins.json @@ -3,6 +3,6 @@ "minVersion": "0.8", "package": "com.gastinelgarde.mixin", "compatibilityLevel": "JAVA_21", - "mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin", "CompletionMixin"], + "mixins": ["MovePacketMixin", "RiptideMoveMixin", "MinecartPushMixin", "CompletionMixin", "ContainerClickMixin"], "injectors": {"defaultRequire": 1} } diff --git a/src/test/java/com/gastinelgarde/MixinsThreadTest.java b/src/test/java/com/gastinelgarde/MixinsThreadTest.java index 66e7798..7238fe9 100644 --- a/src/test/java/com/gastinelgarde/MixinsThreadTest.java +++ b/src/test/java/com/gastinelgarde/MixinsThreadTest.java @@ -74,7 +74,7 @@ class MixinsThreadTest { @Test void F01_aucune_injection_HEAD_dans_un_handle() throws Exception { for (String classe : new String[] {"com.gastinelgarde.mixin.MovePacketMixin", "com.gastinelgarde.mixin.RiptideMoveMixin", - "com.gastinelgarde.mixin.CompletionMixin"}) { + "com.gastinelgarde.mixin.CompletionMixin", "com.gastinelgarde.mixin.ContainerClickMixin"}) { for (Injection i : injections(lire(classe))) { if (!visePaquet(i) || i.at() == null) continue; assertFalse("HEAD".equals(valeur(i.at(), "value")), diff --git a/src/test/java/com/gastinelgarde/core/InventaireP06Test.java b/src/test/java/com/gastinelgarde/core/InventaireP06Test.java new file mode 100644 index 0000000..c177f2c --- /dev/null +++ b/src/test/java/com/gastinelgarde/core/InventaireP06Test.java @@ -0,0 +1,219 @@ +package com.gastinelgarde.core; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.List; +import java.util.UUID; +import org.junit.jupiter.api.Test; + +/** 0.6, P2.6 : inventaire (ChestStealer, InventoryMove, InvCleaner / AutoArmor). */ +class InventaireP06Test { + + private final GardeConfig cfg = new GardeConfig(); + private final UUID joueur = UUID.randomUUID(); + + private static EtatJoueur ping(int ms) { + return EtatJoueur.builder().pingMs(ms).build(); + } + + private static int compter(List v) { + int n = 0; + for (Verdict x : v) if (x.controle() == Controle.INVENTAIRE && x.points() > 0) n++; + return n; + } + + /** Ouvre un coffre au tick 100 et prend n objets différents à partir de {@code debut}, un tous les {@code pas} ticks. */ + private int session(Moteur m, EtatJoueur e, long debut, int pas, int n, boolean memeObjet) { + m.ouvrirConteneur(joueur, 100); + int verdicts = 0; + for (int i = 0; i < n; i++) { + long t = debut + (long) i * pas; + verdicts += compter(m.clicConteneur(joueur, t * 50L, t, e, true, true, Inventaire.Clic.PRISE, true, + memeObjet ? 7 : 10 + i)); + } + return verdicts; + } + + @Test + void observeParDefautEtSeuilsPropres() { + assertEquals(Mode.OBSERVE, cfg.mode(Controle.INVENTAIRE)); + assertEquals(Controle.INVENTAIRE, Controle.parse("inventaire")); + cfg.inventaireSeuilSetback = 4; + assertEquals(Sanction.SETBACK, Paliers.palier(5, cfg, Controle.INVENTAIRE)); + assertEquals(Sanction.ALERTE, Paliers.palier(5, cfg, Controle.TOWER)); // les autres gardent le seuil global + } + + @Test + void humainRapideNonVu() { + // Réaction 300 ms (6 ticks, ping 50), puis un shift-clic tous les 2 ticks : très rapide mais humain. + assertEquals(0, session(new Moteur(cfg), ping(50), 106, 2, 27, false)); + } + + @Test + void doubleClicShiftVanillaNonVu() { + // Shift + double-clic : toutes les cases du même objet dans le même tick, dès 2 ticks après l'ouverture. + assertEquals(0, session(new Moteur(cfg), ping(0), 102, 0, 27, true)); + } + + @Test + void mouseTweaksApresReactionHumaineNonVu() { + // Glisser shift sur 9 cases en 2 ticks, mais 400 ms après l'ouverture : la réaction humaine sauve le joueur. + Moteur m = new Moteur(cfg); + m.ouvrirConteneur(joueur, 100); + int n = 0; + for (int i = 0; i < 9; i++) { + long t = 108 + i / 5; + n += compter(m.clicConteneur(joueur, t * 50L, t, ping(0), true, true, Inventaire.Clic.PRISE, true, 10 + i)); + } + assertEquals(0, n); + } + + @Test + void pingEleveHonneteNonVu() { + // Ping 400 ms (plafonné à 300) : 650 ms après l'ouverture, réaction calculée 350 ms. + assertEquals(0, session(new Moteur(cfg), ping(400), 113, 1, 27, false)); + } + + @Test + void chestStealerVuEtChaquePriseSuivanteCompte() { + // Prises dès le tick suivant l'ouverture (ping 50 retiré : réaction 0), une par tick. + int v = session(new Moteur(cfg), ping(50), 101, 1, 27, false); + assertEquals(27 - cfg.inventairePrisesMin + 1, v); + } + + @Test + void stealerQuiGonfleSonPingVuQuandMeme() { + // Ping déclaré 2000 ms : plafonné à 300, la réaction reste nulle. + assertTrue(session(new Moteur(cfg), ping(2000), 101, 1, 20, false) > 0); + } + + @Test + void stealerLentNonVuLimiteConnue() { + // Délai aléatoire de 150 ms : intervalle moyen 3 ticks, pas vu (limite documentée). + assertEquals(0, session(new Moteur(cfg), ping(0), 101, 3, 27, false)); + } + + @Test + void creatifSpectateurEtGelServeurExemptes() { + for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().creatif(true).build(), + EtatJoueur.builder().spectateur(true).build(), EtatJoueur.builder().ticksDepuisGel(5).build()}) { + assertEquals(0, session(new Moteur(cfg), e, 101, 1, 27, false), e.toString()); + } + } + + @Test + void lagServeurAssouplit() { + // TPS bas : paquets regroupés. Réaction exigée et intervalle maximal divisés par facteurLag (1,5) : réaction + // 66 ms au lieu de 100, intervalle 1,0 tick au lieu de 1,5. Première prise au tick 102 (100 ms) : jamais vue. + EtatJoueur lag = EtatJoueur.builder().tps(15).build(); + assertTrue(session(new Moteur(cfg), EtatJoueur.normal(), 101, 1, 20, false) > 0); + assertEquals(0, session(new Moteur(cfg), lag, 102, 1, 20, false)); + // Prises groupées 2 par tick (intervalle moyen 0,5) dès l'ouverture : vues même sous lag. + Moteur m = new Moteur(cfg); + m.ouvrirConteneur(joueur, 100); + int n = 0; + for (int i = 0; i < 20; i++) { + long t = 100 + i / 2; + n += compter(m.clicConteneur(joueur, t * 50L, t, lag, true, true, Inventaire.Clic.PRISE, true, 10 + i)); + } + assertTrue(n > 0); + } + + @Test + void rotationEcranOuvertApresGraceVue() { + Moteur m = new Moteur(cfg); + m.regardInventaire(joueur, 0, 90, EtatJoueur.normal(), 0, 0); + m.ouvrirConteneur(joueur, 100); + int n = 0; + for (int t = 101; t < 140; t++) { + n += compter(m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 3f, 10)); + } + // grâce 10 ticks : rotations comptées à partir du tick 111, la 3e et les suivantes donnent des points + assertEquals(139 - 111 + 1 - (cfg.inventaireRotationsMin - 1), n); + } + + @Test + void rotationPendantLaGraceOuSansConteneurNonVue() { + Moteur m = new Moteur(cfg); + m.regardInventaire(joueur, 0, 90, EtatJoueur.normal(), 0, 0); + m.ouvrirConteneur(joueur, 100); + int n = 0; + // le client n'a pas encore reçu l'écran (aller-retour) : il tourne encore + for (int t = 101; t <= 110; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 3f, 0)); + m.fermerConteneur(joueur); + for (int t = 111; t < 200; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 3f, 0)); + assertEquals(0, n); + } + + @Test + void rotationEnVehiculeOuTeleportNonVue() { + for (EtatJoueur e : new EtatJoueur[] {EtatJoueur.builder().enVehicule(true).build(), + EtatJoueur.builder().ticksDepuisTeleport(0).build(), EtatJoueur.builder().elytres(true).build()}) { + Moteur m = new Moteur(cfg); + m.ouvrirConteneur(joueur, 100); + int n = 0; + for (int t = 101; t < 160; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, e, t * 3f, 0)); + assertEquals(0, n, e.toString()); + } + } + + @Test + void pingEleveAllongeLaGrace() { + Moteur m = new Moteur(cfg); + EtatJoueur e = ping(500); // grâce 10 + 10 ticks + m.regardInventaire(joueur, 0, 90, e, 0, 0); + m.ouvrirConteneur(joueur, 100); + int n = 0; + for (int t = 101; t <= 120; t++) n += compter(m.regardInventaire(joueur, t * 50L, t, e, t * 3f, 0)); + assertEquals(0, n); + } + + @Test + void invCleanerPendantRotationVu() { + Moteur m = new Moteur(cfg); + int n = 0; + for (int t = 100; t < 120; t++) { + m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), t * 5f, 0); + n += compter(m.clicConteneur(joueur, t * 50L, t, EtatJoueur.normal(), true, false, Inventaire.Clic.PRISE, false, 3)); + } + assertTrue(n > 10); + } + + @Test + void clicInventaireTeteImmobileNonVu() { + Moteur m = new Moteur(cfg); + m.regardInventaire(joueur, 0, 90, EtatJoueur.normal(), 0, 0); + int n = 0; + for (int t = 100; t < 160; t++) { + m.regardInventaire(joueur, t * 50L, t, EtatJoueur.normal(), 0, 0); + n += compter(m.clicConteneur(joueur, t * 50L, t, EtatJoueur.normal(), true, false, Inventaire.Clic.PRISE, false, 3)); + } + assertEquals(0, n); + } + + @Test + void clicsSurConteneurFermeJournalSeulementEnSerie() { + Moteur m = new Moteur(cfg); + int n = 0; + for (int i = 0; i < 3; i++) n += m.clicConteneur(joueur, 1000 + i, 20, EtatJoueur.normal(), false, false, + Inventaire.Clic.PRISE, false, 0).size(); + assertEquals(0, n); + for (int i = 3; i < 12; i++) n += m.clicConteneur(joueur, 1000 + i, 20, EtatJoueur.normal(), false, false, + Inventaire.Clic.PRISE, false, 0).size(); + assertTrue(n > 0); + assertTrue(m.suivi(joueur).vl.valeur(Controle.INVENTAIRE, 1012) < cfg.seuilAlerte); + } + + @Test + void etatOublieALaDeconnexion() { + Moteur m = new Moteur(cfg); + session(m, ping(0), 101, 1, 10, false); + Suivi avant = m.suivi(joueur); + assertTrue(avant.inventaire.sessionSuspecte()); + m.retirer(joueur); + assertNotSame(avant, m.suivi(joueur)); + assertTrue(!m.suivi(joueur).inventaire.sessionSuspecte() && !m.suivi(joueur).inventaire.ouvert()); + } +}